package com.test.test_rest.blockchain_data.domain.gen;

import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;

public class GirdJobConfigCriteria {
    protected String orderByClause;

    protected boolean distinct;

    protected List<Criteria> oredCriteria;

    protected Integer mysqlOffset;

    protected Integer mysqlLength;

    protected String isCURD;

    public GirdJobConfigCriteria() {
        oredCriteria = new ArrayList<Criteria>();
    }

    public void setOrderByClause(String orderByClause) {
        this.orderByClause = orderByClause;
    }

    public String getOrderByClause() {
        return orderByClause;
    }

    public void setDistinct(boolean distinct) {
        this.distinct = distinct;
    }

    public boolean isDistinct() {
        return distinct;
    }

    public List<Criteria> getOredCriteria() {
        return oredCriteria;
    }

    public void or(Criteria criteria) {
        oredCriteria.add(criteria);
    }

    public Criteria or() {
        Criteria criteria = createCriteriaInternal();
        oredCriteria.add(criteria);
        return criteria;
    }

    public Criteria createCriteria() {
        Criteria criteria = createCriteriaInternal();
        if (oredCriteria.size() == 0) {
            oredCriteria.add(criteria);
        }
        return criteria;
    }

    protected Criteria createCriteriaInternal() {
        Criteria criteria = new Criteria();
        return criteria;
    }

    public void clear() {
        oredCriteria.clear();
        orderByClause = null;
        distinct = false;
    }

    /**
     * @param mysqlOffset 
	 *            指定返回记录行的偏移量<br>
	 *            mysqlOffset= 5,mysqlLength=10;  // 检索记录行 6-15
     */
    public void setMysqlOffset(Integer mysqlOffset) {
        this.mysqlOffset=mysqlOffset;
    }

    /**
     * @param mysqlLength 
	 *            指定返回记录行的最大数目<br>
	 *            mysqlOffset= 5,mysqlLength=10;  // 检索记录行 6-15
     */
    public Integer getMysqlOffset() {
        return mysqlOffset;
    }

    /**
     * @param mysqlOffset 
	 *            指定返回记录行的偏移量<br>
	 *            mysqlOffset= 5,mysqlLength=10;  // 检索记录行 6-15
     */
    public void setMysqlLength(Integer mysqlLength) {
        this.mysqlLength=mysqlLength;
    }

    /**
     * @param mysqlLength 
	 *            指定返回记录行的最大数目<br>
	 *            mysqlOffset= 5,mysqlLength=10;  // 检索记录行 6-15
     */
    public Integer getMysqlLength() {
        return mysqlLength;
    }

    public void setIsCURD(String isCURD) {
        this.isCURD=isCURD;
    }

    public String getIsCURD() {
        return isCURD;
    }

    protected abstract static class GeneratedCriteria {
        protected List<Criterion> criteria;

        protected GeneratedCriteria() {
            super();
            criteria = new ArrayList<Criterion>();
        }

        public boolean isValid() {
            return criteria.size() > 0;
        }

        public List<Criterion> getAllCriteria() {
            return criteria;
        }

        public List<Criterion> getCriteria() {
            return criteria;
        }

        protected void addCriterion(String condition) {
            if (condition == null) {
                throw new RuntimeException("Value for condition cannot be null");
            }
            criteria.add(new Criterion(condition));
        }

        protected void addCriterion(String condition, Object value, String property) {
            if (value == null) {
                throw new RuntimeException("Value for " + property + " cannot be null");
            }
            criteria.add(new Criterion(condition, value));
        }

        protected void addCriterion(String condition, Object value1, Object value2, String property) {
            if (value1 == null || value2 == null) {
                throw new RuntimeException("Between values for " + property + " cannot be null");
            }
            criteria.add(new Criterion(condition, value1, value2));
        }

        public Criteria andIdIsNull() {
            addCriterion("ID is null");
            return (Criteria) this;
        }

        public Criteria andIdIsNotNull() {
            addCriterion("ID is not null");
            return (Criteria) this;
        }

        public Criteria andIdEqualTo(Integer value) {
            addCriterion("ID =", value, "id");
            return (Criteria) this;
        }

        public Criteria andIdNotEqualTo(Integer value) {
            addCriterion("ID <>", value, "id");
            return (Criteria) this;
        }

        public Criteria andIdGreaterThan(Integer value) {
            addCriterion("ID >", value, "id");
            return (Criteria) this;
        }

        public Criteria andIdGreaterThanOrEqualTo(Integer value) {
            addCriterion("ID >=", value, "id");
            return (Criteria) this;
        }

        public Criteria andIdLessThan(Integer value) {
            addCriterion("ID <", value, "id");
            return (Criteria) this;
        }

        public Criteria andIdLessThanOrEqualTo(Integer value) {
            addCriterion("ID <=", value, "id");
            return (Criteria) this;
        }

        public Criteria andIdIn(List<Integer> values) {
            addCriterion("ID in", values, "id");
            return (Criteria) this;
        }

        public Criteria andIdNotIn(List<Integer> values) {
            addCriterion("ID not in", values, "id");
            return (Criteria) this;
        }

        public Criteria andIdBetween(Integer value1, Integer value2) {
            addCriterion("ID between", value1, value2, "id");
            return (Criteria) this;
        }

        public Criteria andIdNotBetween(Integer value1, Integer value2) {
            addCriterion("ID not between", value1, value2, "id");
            return (Criteria) this;
        }

        public Criteria andSymbolIsNull() {
            addCriterion("SYMBOL is null");
            return (Criteria) this;
        }

        public Criteria andSymbolIsNotNull() {
            addCriterion("SYMBOL is not null");
            return (Criteria) this;
        }

        public Criteria andSymbolEqualTo(String value) {
            addCriterion("SYMBOL =", value, "symbol");
            return (Criteria) this;
        }

        public Criteria andSymbolNotEqualTo(String value) {
            addCriterion("SYMBOL <>", value, "symbol");
            return (Criteria) this;
        }

        public Criteria andSymbolGreaterThan(String value) {
            addCriterion("SYMBOL >", value, "symbol");
            return (Criteria) this;
        }

        public Criteria andSymbolGreaterThanOrEqualTo(String value) {
            addCriterion("SYMBOL >=", value, "symbol");
            return (Criteria) this;
        }

        public Criteria andSymbolLessThan(String value) {
            addCriterion("SYMBOL <", value, "symbol");
            return (Criteria) this;
        }

        public Criteria andSymbolLessThanOrEqualTo(String value) {
            addCriterion("SYMBOL <=", value, "symbol");
            return (Criteria) this;
        }

        public Criteria andSymbolLike(String value) {
            addCriterion("SYMBOL like", value, "symbol");
            return (Criteria) this;
        }

        public Criteria andSymbolNotLike(String value) {
            addCriterion("SYMBOL not like", value, "symbol");
            return (Criteria) this;
        }

        public Criteria andSymbolIn(List<String> values) {
            addCriterion("SYMBOL in", values, "symbol");
            return (Criteria) this;
        }

        public Criteria andSymbolNotIn(List<String> values) {
            addCriterion("SYMBOL not in", values, "symbol");
            return (Criteria) this;
        }

        public Criteria andSymbolBetween(String value1, String value2) {
            addCriterion("SYMBOL between", value1, value2, "symbol");
            return (Criteria) this;
        }

        public Criteria andSymbolNotBetween(String value1, String value2) {
            addCriterion("SYMBOL not between", value1, value2, "symbol");
            return (Criteria) this;
        }

        public Criteria andCompleteJobIsNull() {
            addCriterion("COMPLETE_JOB is null");
            return (Criteria) this;
        }

        public Criteria andCompleteJobIsNotNull() {
            addCriterion("COMPLETE_JOB is not null");
            return (Criteria) this;
        }

        public Criteria andCompleteJobEqualTo(Integer value) {
            addCriterion("COMPLETE_JOB =", value, "completeJob");
            return (Criteria) this;
        }

        public Criteria andCompleteJobNotEqualTo(Integer value) {
            addCriterion("COMPLETE_JOB <>", value, "completeJob");
            return (Criteria) this;
        }

        public Criteria andCompleteJobGreaterThan(Integer value) {
            addCriterion("COMPLETE_JOB >", value, "completeJob");
            return (Criteria) this;
        }

        public Criteria andCompleteJobGreaterThanOrEqualTo(Integer value) {
            addCriterion("COMPLETE_JOB >=", value, "completeJob");
            return (Criteria) this;
        }

        public Criteria andCompleteJobLessThan(Integer value) {
            addCriterion("COMPLETE_JOB <", value, "completeJob");
            return (Criteria) this;
        }

        public Criteria andCompleteJobLessThanOrEqualTo(Integer value) {
            addCriterion("COMPLETE_JOB <=", value, "completeJob");
            return (Criteria) this;
        }

        public Criteria andCompleteJobIn(List<Integer> values) {
            addCriterion("COMPLETE_JOB in", values, "completeJob");
            return (Criteria) this;
        }

        public Criteria andCompleteJobNotIn(List<Integer> values) {
            addCriterion("COMPLETE_JOB not in", values, "completeJob");
            return (Criteria) this;
        }

        public Criteria andCompleteJobBetween(Integer value1, Integer value2) {
            addCriterion("COMPLETE_JOB between", value1, value2, "completeJob");
            return (Criteria) this;
        }

        public Criteria andCompleteJobNotBetween(Integer value1, Integer value2) {
            addCriterion("COMPLETE_JOB not between", value1, value2, "completeJob");
            return (Criteria) this;
        }

        public Criteria andTotalJobIsNull() {
            addCriterion("TOTAL_JOB is null");
            return (Criteria) this;
        }

        public Criteria andTotalJobIsNotNull() {
            addCriterion("TOTAL_JOB is not null");
            return (Criteria) this;
        }

        public Criteria andTotalJobEqualTo(Integer value) {
            addCriterion("TOTAL_JOB =", value, "totalJob");
            return (Criteria) this;
        }

        public Criteria andTotalJobNotEqualTo(Integer value) {
            addCriterion("TOTAL_JOB <>", value, "totalJob");
            return (Criteria) this;
        }

        public Criteria andTotalJobGreaterThan(Integer value) {
            addCriterion("TOTAL_JOB >", value, "totalJob");
            return (Criteria) this;
        }

        public Criteria andTotalJobGreaterThanOrEqualTo(Integer value) {
            addCriterion("TOTAL_JOB >=", value, "totalJob");
            return (Criteria) this;
        }

        public Criteria andTotalJobLessThan(Integer value) {
            addCriterion("TOTAL_JOB <", value, "totalJob");
            return (Criteria) this;
        }

        public Criteria andTotalJobLessThanOrEqualTo(Integer value) {
            addCriterion("TOTAL_JOB <=", value, "totalJob");
            return (Criteria) this;
        }

        public Criteria andTotalJobIn(List<Integer> values) {
            addCriterion("TOTAL_JOB in", values, "totalJob");
            return (Criteria) this;
        }

        public Criteria andTotalJobNotIn(List<Integer> values) {
            addCriterion("TOTAL_JOB not in", values, "totalJob");
            return (Criteria) this;
        }

        public Criteria andTotalJobBetween(Integer value1, Integer value2) {
            addCriterion("TOTAL_JOB between", value1, value2, "totalJob");
            return (Criteria) this;
        }

        public Criteria andTotalJobNotBetween(Integer value1, Integer value2) {
            addCriterion("TOTAL_JOB not between", value1, value2, "totalJob");
            return (Criteria) this;
        }

        public Criteria andSumAmountIsNull() {
            addCriterion("SUM_AMOUNT is null");
            return (Criteria) this;
        }

        public Criteria andSumAmountIsNotNull() {
            addCriterion("SUM_AMOUNT is not null");
            return (Criteria) this;
        }

        public Criteria andSumAmountEqualTo(BigDecimal value) {
            addCriterion("SUM_AMOUNT =", value, "sumAmount");
            return (Criteria) this;
        }

        public Criteria andSumAmountNotEqualTo(BigDecimal value) {
            addCriterion("SUM_AMOUNT <>", value, "sumAmount");
            return (Criteria) this;
        }

        public Criteria andSumAmountGreaterThan(BigDecimal value) {
            addCriterion("SUM_AMOUNT >", value, "sumAmount");
            return (Criteria) this;
        }

        public Criteria andSumAmountGreaterThanOrEqualTo(BigDecimal value) {
            addCriterion("SUM_AMOUNT >=", value, "sumAmount");
            return (Criteria) this;
        }

        public Criteria andSumAmountLessThan(BigDecimal value) {
            addCriterion("SUM_AMOUNT <", value, "sumAmount");
            return (Criteria) this;
        }

        public Criteria andSumAmountLessThanOrEqualTo(BigDecimal value) {
            addCriterion("SUM_AMOUNT <=", value, "sumAmount");
            return (Criteria) this;
        }

        public Criteria andSumAmountIn(List<BigDecimal> values) {
            addCriterion("SUM_AMOUNT in", values, "sumAmount");
            return (Criteria) this;
        }

        public Criteria andSumAmountNotIn(List<BigDecimal> values) {
            addCriterion("SUM_AMOUNT not in", values, "sumAmount");
            return (Criteria) this;
        }

        public Criteria andSumAmountBetween(BigDecimal value1, BigDecimal value2) {
            addCriterion("SUM_AMOUNT between", value1, value2, "sumAmount");
            return (Criteria) this;
        }

        public Criteria andSumAmountNotBetween(BigDecimal value1, BigDecimal value2) {
            addCriterion("SUM_AMOUNT not between", value1, value2, "sumAmount");
            return (Criteria) this;
        }

        public Criteria andStatusIsNull() {
            addCriterion("STATUS is null");
            return (Criteria) this;
        }

        public Criteria andStatusIsNotNull() {
            addCriterion("STATUS is not null");
            return (Criteria) this;
        }

        public Criteria andStatusEqualTo(String value) {
            addCriterion("STATUS =", value, "status");
            return (Criteria) this;
        }

        public Criteria andStatusNotEqualTo(String value) {
            addCriterion("STATUS <>", value, "status");
            return (Criteria) this;
        }

        public Criteria andStatusGreaterThan(String value) {
            addCriterion("STATUS >", value, "status");
            return (Criteria) this;
        }

        public Criteria andStatusGreaterThanOrEqualTo(String value) {
            addCriterion("STATUS >=", value, "status");
            return (Criteria) this;
        }

        public Criteria andStatusLessThan(String value) {
            addCriterion("STATUS <", value, "status");
            return (Criteria) this;
        }

        public Criteria andStatusLessThanOrEqualTo(String value) {
            addCriterion("STATUS <=", value, "status");
            return (Criteria) this;
        }

        public Criteria andStatusLike(String value) {
            addCriterion("STATUS like", value, "status");
            return (Criteria) this;
        }

        public Criteria andStatusNotLike(String value) {
            addCriterion("STATUS not like", value, "status");
            return (Criteria) this;
        }

        public Criteria andStatusIn(List<String> values) {
            addCriterion("STATUS in", values, "status");
            return (Criteria) this;
        }

        public Criteria andStatusNotIn(List<String> values) {
            addCriterion("STATUS not in", values, "status");
            return (Criteria) this;
        }

        public Criteria andStatusBetween(String value1, String value2) {
            addCriterion("STATUS between", value1, value2, "status");
            return (Criteria) this;
        }

        public Criteria andStatusNotBetween(String value1, String value2) {
            addCriterion("STATUS not between", value1, value2, "status");
            return (Criteria) this;
        }

        public Criteria andCreateTimeIsNull() {
            addCriterion("CREATE_TIME is null");
            return (Criteria) this;
        }

        public Criteria andCreateTimeIsNotNull() {
            addCriterion("CREATE_TIME is not null");
            return (Criteria) this;
        }

        public Criteria andCreateTimeEqualTo(Date value) {
            addCriterion("CREATE_TIME =", value, "createTime");
            return (Criteria) this;
        }

        public Criteria andCreateTimeNotEqualTo(Date value) {
            addCriterion("CREATE_TIME <>", value, "createTime");
            return (Criteria) this;
        }

        public Criteria andCreateTimeGreaterThan(Date value) {
            addCriterion("CREATE_TIME >", value, "createTime");
            return (Criteria) this;
        }

        public Criteria andCreateTimeGreaterThanOrEqualTo(Date value) {
            addCriterion("CREATE_TIME >=", value, "createTime");
            return (Criteria) this;
        }

        public Criteria andCreateTimeLessThan(Date value) {
            addCriterion("CREATE_TIME <", value, "createTime");
            return (Criteria) this;
        }

        public Criteria andCreateTimeLessThanOrEqualTo(Date value) {
            addCriterion("CREATE_TIME <=", value, "createTime");
            return (Criteria) this;
        }

        public Criteria andCreateTimeIn(List<Date> values) {
            addCriterion("CREATE_TIME in", values, "createTime");
            return (Criteria) this;
        }

        public Criteria andCreateTimeNotIn(List<Date> values) {
            addCriterion("CREATE_TIME not in", values, "createTime");
            return (Criteria) this;
        }

        public Criteria andCreateTimeBetween(Date value1, Date value2) {
            addCriterion("CREATE_TIME between", value1, value2, "createTime");
            return (Criteria) this;
        }

        public Criteria andCreateTimeNotBetween(Date value1, Date value2) {
            addCriterion("CREATE_TIME not between", value1, value2, "createTime");
            return (Criteria) this;
        }

        public Criteria andStopProfit1IsNull() {
            addCriterion("STOP_PROFIT_1 is null");
            return (Criteria) this;
        }

        public Criteria andStopProfit1IsNotNull() {
            addCriterion("STOP_PROFIT_1 is not null");
            return (Criteria) this;
        }

        public Criteria andStopProfit1EqualTo(BigDecimal value) {
            addCriterion("STOP_PROFIT_1 =", value, "stopProfit1");
            return (Criteria) this;
        }

        public Criteria andStopProfit1NotEqualTo(BigDecimal value) {
            addCriterion("STOP_PROFIT_1 <>", value, "stopProfit1");
            return (Criteria) this;
        }

        public Criteria andStopProfit1GreaterThan(BigDecimal value) {
            addCriterion("STOP_PROFIT_1 >", value, "stopProfit1");
            return (Criteria) this;
        }

        public Criteria andStopProfit1GreaterThanOrEqualTo(BigDecimal value) {
            addCriterion("STOP_PROFIT_1 >=", value, "stopProfit1");
            return (Criteria) this;
        }

        public Criteria andStopProfit1LessThan(BigDecimal value) {
            addCriterion("STOP_PROFIT_1 <", value, "stopProfit1");
            return (Criteria) this;
        }

        public Criteria andStopProfit1LessThanOrEqualTo(BigDecimal value) {
            addCriterion("STOP_PROFIT_1 <=", value, "stopProfit1");
            return (Criteria) this;
        }

        public Criteria andStopProfit1In(List<BigDecimal> values) {
            addCriterion("STOP_PROFIT_1 in", values, "stopProfit1");
            return (Criteria) this;
        }

        public Criteria andStopProfit1NotIn(List<BigDecimal> values) {
            addCriterion("STOP_PROFIT_1 not in", values, "stopProfit1");
            return (Criteria) this;
        }

        public Criteria andStopProfit1Between(BigDecimal value1, BigDecimal value2) {
            addCriterion("STOP_PROFIT_1 between", value1, value2, "stopProfit1");
            return (Criteria) this;
        }

        public Criteria andStopProfit1NotBetween(BigDecimal value1, BigDecimal value2) {
            addCriterion("STOP_PROFIT_1 not between", value1, value2, "stopProfit1");
            return (Criteria) this;
        }

        public Criteria andStopProfit2IsNull() {
            addCriterion("STOP_PROFIT_2 is null");
            return (Criteria) this;
        }

        public Criteria andStopProfit2IsNotNull() {
            addCriterion("STOP_PROFIT_2 is not null");
            return (Criteria) this;
        }

        public Criteria andStopProfit2EqualTo(BigDecimal value) {
            addCriterion("STOP_PROFIT_2 =", value, "stopProfit2");
            return (Criteria) this;
        }

        public Criteria andStopProfit2NotEqualTo(BigDecimal value) {
            addCriterion("STOP_PROFIT_2 <>", value, "stopProfit2");
            return (Criteria) this;
        }

        public Criteria andStopProfit2GreaterThan(BigDecimal value) {
            addCriterion("STOP_PROFIT_2 >", value, "stopProfit2");
            return (Criteria) this;
        }

        public Criteria andStopProfit2GreaterThanOrEqualTo(BigDecimal value) {
            addCriterion("STOP_PROFIT_2 >=", value, "stopProfit2");
            return (Criteria) this;
        }

        public Criteria andStopProfit2LessThan(BigDecimal value) {
            addCriterion("STOP_PROFIT_2 <", value, "stopProfit2");
            return (Criteria) this;
        }

        public Criteria andStopProfit2LessThanOrEqualTo(BigDecimal value) {
            addCriterion("STOP_PROFIT_2 <=", value, "stopProfit2");
            return (Criteria) this;
        }

        public Criteria andStopProfit2In(List<BigDecimal> values) {
            addCriterion("STOP_PROFIT_2 in", values, "stopProfit2");
            return (Criteria) this;
        }

        public Criteria andStopProfit2NotIn(List<BigDecimal> values) {
            addCriterion("STOP_PROFIT_2 not in", values, "stopProfit2");
            return (Criteria) this;
        }

        public Criteria andStopProfit2Between(BigDecimal value1, BigDecimal value2) {
            addCriterion("STOP_PROFIT_2 between", value1, value2, "stopProfit2");
            return (Criteria) this;
        }

        public Criteria andStopProfit2NotBetween(BigDecimal value1, BigDecimal value2) {
            addCriterion("STOP_PROFIT_2 not between", value1, value2, "stopProfit2");
            return (Criteria) this;
        }

        public Criteria andStopProfitStepIsNull() {
            addCriterion("STOP_PROFIT_STEP is null");
            return (Criteria) this;
        }

        public Criteria andStopProfitStepIsNotNull() {
            addCriterion("STOP_PROFIT_STEP is not null");
            return (Criteria) this;
        }

        public Criteria andStopProfitStepEqualTo(BigDecimal value) {
            addCriterion("STOP_PROFIT_STEP =", value, "stopProfitStep");
            return (Criteria) this;
        }

        public Criteria andStopProfitStepNotEqualTo(BigDecimal value) {
            addCriterion("STOP_PROFIT_STEP <>", value, "stopProfitStep");
            return (Criteria) this;
        }

        public Criteria andStopProfitStepGreaterThan(BigDecimal value) {
            addCriterion("STOP_PROFIT_STEP >", value, "stopProfitStep");
            return (Criteria) this;
        }

        public Criteria andStopProfitStepGreaterThanOrEqualTo(BigDecimal value) {
            addCriterion("STOP_PROFIT_STEP >=", value, "stopProfitStep");
            return (Criteria) this;
        }

        public Criteria andStopProfitStepLessThan(BigDecimal value) {
            addCriterion("STOP_PROFIT_STEP <", value, "stopProfitStep");
            return (Criteria) this;
        }

        public Criteria andStopProfitStepLessThanOrEqualTo(BigDecimal value) {
            addCriterion("STOP_PROFIT_STEP <=", value, "stopProfitStep");
            return (Criteria) this;
        }

        public Criteria andStopProfitStepIn(List<BigDecimal> values) {
            addCriterion("STOP_PROFIT_STEP in", values, "stopProfitStep");
            return (Criteria) this;
        }

        public Criteria andStopProfitStepNotIn(List<BigDecimal> values) {
            addCriterion("STOP_PROFIT_STEP not in", values, "stopProfitStep");
            return (Criteria) this;
        }

        public Criteria andStopProfitStepBetween(BigDecimal value1, BigDecimal value2) {
            addCriterion("STOP_PROFIT_STEP between", value1, value2, "stopProfitStep");
            return (Criteria) this;
        }

        public Criteria andStopProfitStepNotBetween(BigDecimal value1, BigDecimal value2) {
            addCriterion("STOP_PROFIT_STEP not between", value1, value2, "stopProfitStep");
            return (Criteria) this;
        }

        public Criteria andStopProfitCallback1IsNull() {
            addCriterion("STOP_PROFIT_CALLBACK_1 is null");
            return (Criteria) this;
        }

        public Criteria andStopProfitCallback1IsNotNull() {
            addCriterion("STOP_PROFIT_CALLBACK_1 is not null");
            return (Criteria) this;
        }

        public Criteria andStopProfitCallback1EqualTo(BigDecimal value) {
            addCriterion("STOP_PROFIT_CALLBACK_1 =", value, "stopProfitCallback1");
            return (Criteria) this;
        }

        public Criteria andStopProfitCallback1NotEqualTo(BigDecimal value) {
            addCriterion("STOP_PROFIT_CALLBACK_1 <>", value, "stopProfitCallback1");
            return (Criteria) this;
        }

        public Criteria andStopProfitCallback1GreaterThan(BigDecimal value) {
            addCriterion("STOP_PROFIT_CALLBACK_1 >", value, "stopProfitCallback1");
            return (Criteria) this;
        }

        public Criteria andStopProfitCallback1GreaterThanOrEqualTo(BigDecimal value) {
            addCriterion("STOP_PROFIT_CALLBACK_1 >=", value, "stopProfitCallback1");
            return (Criteria) this;
        }

        public Criteria andStopProfitCallback1LessThan(BigDecimal value) {
            addCriterion("STOP_PROFIT_CALLBACK_1 <", value, "stopProfitCallback1");
            return (Criteria) this;
        }

        public Criteria andStopProfitCallback1LessThanOrEqualTo(BigDecimal value) {
            addCriterion("STOP_PROFIT_CALLBACK_1 <=", value, "stopProfitCallback1");
            return (Criteria) this;
        }

        public Criteria andStopProfitCallback1In(List<BigDecimal> values) {
            addCriterion("STOP_PROFIT_CALLBACK_1 in", values, "stopProfitCallback1");
            return (Criteria) this;
        }

        public Criteria andStopProfitCallback1NotIn(List<BigDecimal> values) {
            addCriterion("STOP_PROFIT_CALLBACK_1 not in", values, "stopProfitCallback1");
            return (Criteria) this;
        }

        public Criteria andStopProfitCallback1Between(BigDecimal value1, BigDecimal value2) {
            addCriterion("STOP_PROFIT_CALLBACK_1 between", value1, value2, "stopProfitCallback1");
            return (Criteria) this;
        }

        public Criteria andStopProfitCallback1NotBetween(BigDecimal value1, BigDecimal value2) {
            addCriterion("STOP_PROFIT_CALLBACK_1 not between", value1, value2, "stopProfitCallback1");
            return (Criteria) this;
        }

        public Criteria andStopProfitCallback2IsNull() {
            addCriterion("STOP_PROFIT_CALLBACK_2 is null");
            return (Criteria) this;
        }

        public Criteria andStopProfitCallback2IsNotNull() {
            addCriterion("STOP_PROFIT_CALLBACK_2 is not null");
            return (Criteria) this;
        }

        public Criteria andStopProfitCallback2EqualTo(BigDecimal value) {
            addCriterion("STOP_PROFIT_CALLBACK_2 =", value, "stopProfitCallback2");
            return (Criteria) this;
        }

        public Criteria andStopProfitCallback2NotEqualTo(BigDecimal value) {
            addCriterion("STOP_PROFIT_CALLBACK_2 <>", value, "stopProfitCallback2");
            return (Criteria) this;
        }

        public Criteria andStopProfitCallback2GreaterThan(BigDecimal value) {
            addCriterion("STOP_PROFIT_CALLBACK_2 >", value, "stopProfitCallback2");
            return (Criteria) this;
        }

        public Criteria andStopProfitCallback2GreaterThanOrEqualTo(BigDecimal value) {
            addCriterion("STOP_PROFIT_CALLBACK_2 >=", value, "stopProfitCallback2");
            return (Criteria) this;
        }

        public Criteria andStopProfitCallback2LessThan(BigDecimal value) {
            addCriterion("STOP_PROFIT_CALLBACK_2 <", value, "stopProfitCallback2");
            return (Criteria) this;
        }

        public Criteria andStopProfitCallback2LessThanOrEqualTo(BigDecimal value) {
            addCriterion("STOP_PROFIT_CALLBACK_2 <=", value, "stopProfitCallback2");
            return (Criteria) this;
        }

        public Criteria andStopProfitCallback2In(List<BigDecimal> values) {
            addCriterion("STOP_PROFIT_CALLBACK_2 in", values, "stopProfitCallback2");
            return (Criteria) this;
        }

        public Criteria andStopProfitCallback2NotIn(List<BigDecimal> values) {
            addCriterion("STOP_PROFIT_CALLBACK_2 not in", values, "stopProfitCallback2");
            return (Criteria) this;
        }

        public Criteria andStopProfitCallback2Between(BigDecimal value1, BigDecimal value2) {
            addCriterion("STOP_PROFIT_CALLBACK_2 between", value1, value2, "stopProfitCallback2");
            return (Criteria) this;
        }

        public Criteria andStopProfitCallback2NotBetween(BigDecimal value1, BigDecimal value2) {
            addCriterion("STOP_PROFIT_CALLBACK_2 not between", value1, value2, "stopProfitCallback2");
            return (Criteria) this;
        }

        public Criteria andStopProfitCallbackStepIsNull() {
            addCriterion("STOP_PROFIT_CALLBACK_STEP is null");
            return (Criteria) this;
        }

        public Criteria andStopProfitCallbackStepIsNotNull() {
            addCriterion("STOP_PROFIT_CALLBACK_STEP is not null");
            return (Criteria) this;
        }

        public Criteria andStopProfitCallbackStepEqualTo(BigDecimal value) {
            addCriterion("STOP_PROFIT_CALLBACK_STEP =", value, "stopProfitCallbackStep");
            return (Criteria) this;
        }

        public Criteria andStopProfitCallbackStepNotEqualTo(BigDecimal value) {
            addCriterion("STOP_PROFIT_CALLBACK_STEP <>", value, "stopProfitCallbackStep");
            return (Criteria) this;
        }

        public Criteria andStopProfitCallbackStepGreaterThan(BigDecimal value) {
            addCriterion("STOP_PROFIT_CALLBACK_STEP >", value, "stopProfitCallbackStep");
            return (Criteria) this;
        }

        public Criteria andStopProfitCallbackStepGreaterThanOrEqualTo(BigDecimal value) {
            addCriterion("STOP_PROFIT_CALLBACK_STEP >=", value, "stopProfitCallbackStep");
            return (Criteria) this;
        }

        public Criteria andStopProfitCallbackStepLessThan(BigDecimal value) {
            addCriterion("STOP_PROFIT_CALLBACK_STEP <", value, "stopProfitCallbackStep");
            return (Criteria) this;
        }

        public Criteria andStopProfitCallbackStepLessThanOrEqualTo(BigDecimal value) {
            addCriterion("STOP_PROFIT_CALLBACK_STEP <=", value, "stopProfitCallbackStep");
            return (Criteria) this;
        }

        public Criteria andStopProfitCallbackStepIn(List<BigDecimal> values) {
            addCriterion("STOP_PROFIT_CALLBACK_STEP in", values, "stopProfitCallbackStep");
            return (Criteria) this;
        }

        public Criteria andStopProfitCallbackStepNotIn(List<BigDecimal> values) {
            addCriterion("STOP_PROFIT_CALLBACK_STEP not in", values, "stopProfitCallbackStep");
            return (Criteria) this;
        }

        public Criteria andStopProfitCallbackStepBetween(BigDecimal value1, BigDecimal value2) {
            addCriterion("STOP_PROFIT_CALLBACK_STEP between", value1, value2, "stopProfitCallbackStep");
            return (Criteria) this;
        }

        public Criteria andStopProfitCallbackStepNotBetween(BigDecimal value1, BigDecimal value2) {
            addCriterion("STOP_PROFIT_CALLBACK_STEP not between", value1, value2, "stopProfitCallbackStep");
            return (Criteria) this;
        }

        public Criteria andUpWeight1IsNull() {
            addCriterion("UP_WEIGHT_1 is null");
            return (Criteria) this;
        }

        public Criteria andUpWeight1IsNotNull() {
            addCriterion("UP_WEIGHT_1 is not null");
            return (Criteria) this;
        }

        public Criteria andUpWeight1EqualTo(BigDecimal value) {
            addCriterion("UP_WEIGHT_1 =", value, "upWeight1");
            return (Criteria) this;
        }

        public Criteria andUpWeight1NotEqualTo(BigDecimal value) {
            addCriterion("UP_WEIGHT_1 <>", value, "upWeight1");
            return (Criteria) this;
        }

        public Criteria andUpWeight1GreaterThan(BigDecimal value) {
            addCriterion("UP_WEIGHT_1 >", value, "upWeight1");
            return (Criteria) this;
        }

        public Criteria andUpWeight1GreaterThanOrEqualTo(BigDecimal value) {
            addCriterion("UP_WEIGHT_1 >=", value, "upWeight1");
            return (Criteria) this;
        }

        public Criteria andUpWeight1LessThan(BigDecimal value) {
            addCriterion("UP_WEIGHT_1 <", value, "upWeight1");
            return (Criteria) this;
        }

        public Criteria andUpWeight1LessThanOrEqualTo(BigDecimal value) {
            addCriterion("UP_WEIGHT_1 <=", value, "upWeight1");
            return (Criteria) this;
        }

        public Criteria andUpWeight1In(List<BigDecimal> values) {
            addCriterion("UP_WEIGHT_1 in", values, "upWeight1");
            return (Criteria) this;
        }

        public Criteria andUpWeight1NotIn(List<BigDecimal> values) {
            addCriterion("UP_WEIGHT_1 not in", values, "upWeight1");
            return (Criteria) this;
        }

        public Criteria andUpWeight1Between(BigDecimal value1, BigDecimal value2) {
            addCriterion("UP_WEIGHT_1 between", value1, value2, "upWeight1");
            return (Criteria) this;
        }

        public Criteria andUpWeight1NotBetween(BigDecimal value1, BigDecimal value2) {
            addCriterion("UP_WEIGHT_1 not between", value1, value2, "upWeight1");
            return (Criteria) this;
        }

        public Criteria andUpWeight2IsNull() {
            addCriterion("UP_WEIGHT_2 is null");
            return (Criteria) this;
        }

        public Criteria andUpWeight2IsNotNull() {
            addCriterion("UP_WEIGHT_2 is not null");
            return (Criteria) this;
        }

        public Criteria andUpWeight2EqualTo(BigDecimal value) {
            addCriterion("UP_WEIGHT_2 =", value, "upWeight2");
            return (Criteria) this;
        }

        public Criteria andUpWeight2NotEqualTo(BigDecimal value) {
            addCriterion("UP_WEIGHT_2 <>", value, "upWeight2");
            return (Criteria) this;
        }

        public Criteria andUpWeight2GreaterThan(BigDecimal value) {
            addCriterion("UP_WEIGHT_2 >", value, "upWeight2");
            return (Criteria) this;
        }

        public Criteria andUpWeight2GreaterThanOrEqualTo(BigDecimal value) {
            addCriterion("UP_WEIGHT_2 >=", value, "upWeight2");
            return (Criteria) this;
        }

        public Criteria andUpWeight2LessThan(BigDecimal value) {
            addCriterion("UP_WEIGHT_2 <", value, "upWeight2");
            return (Criteria) this;
        }

        public Criteria andUpWeight2LessThanOrEqualTo(BigDecimal value) {
            addCriterion("UP_WEIGHT_2 <=", value, "upWeight2");
            return (Criteria) this;
        }

        public Criteria andUpWeight2In(List<BigDecimal> values) {
            addCriterion("UP_WEIGHT_2 in", values, "upWeight2");
            return (Criteria) this;
        }

        public Criteria andUpWeight2NotIn(List<BigDecimal> values) {
            addCriterion("UP_WEIGHT_2 not in", values, "upWeight2");
            return (Criteria) this;
        }

        public Criteria andUpWeight2Between(BigDecimal value1, BigDecimal value2) {
            addCriterion("UP_WEIGHT_2 between", value1, value2, "upWeight2");
            return (Criteria) this;
        }

        public Criteria andUpWeight2NotBetween(BigDecimal value1, BigDecimal value2) {
            addCriterion("UP_WEIGHT_2 not between", value1, value2, "upWeight2");
            return (Criteria) this;
        }

        public Criteria andUpWeightStepIsNull() {
            addCriterion("UP_WEIGHT_STEP is null");
            return (Criteria) this;
        }

        public Criteria andUpWeightStepIsNotNull() {
            addCriterion("UP_WEIGHT_STEP is not null");
            return (Criteria) this;
        }

        public Criteria andUpWeightStepEqualTo(BigDecimal value) {
            addCriterion("UP_WEIGHT_STEP =", value, "upWeightStep");
            return (Criteria) this;
        }

        public Criteria andUpWeightStepNotEqualTo(BigDecimal value) {
            addCriterion("UP_WEIGHT_STEP <>", value, "upWeightStep");
            return (Criteria) this;
        }

        public Criteria andUpWeightStepGreaterThan(BigDecimal value) {
            addCriterion("UP_WEIGHT_STEP >", value, "upWeightStep");
            return (Criteria) this;
        }

        public Criteria andUpWeightStepGreaterThanOrEqualTo(BigDecimal value) {
            addCriterion("UP_WEIGHT_STEP >=", value, "upWeightStep");
            return (Criteria) this;
        }

        public Criteria andUpWeightStepLessThan(BigDecimal value) {
            addCriterion("UP_WEIGHT_STEP <", value, "upWeightStep");
            return (Criteria) this;
        }

        public Criteria andUpWeightStepLessThanOrEqualTo(BigDecimal value) {
            addCriterion("UP_WEIGHT_STEP <=", value, "upWeightStep");
            return (Criteria) this;
        }

        public Criteria andUpWeightStepIn(List<BigDecimal> values) {
            addCriterion("UP_WEIGHT_STEP in", values, "upWeightStep");
            return (Criteria) this;
        }

        public Criteria andUpWeightStepNotIn(List<BigDecimal> values) {
            addCriterion("UP_WEIGHT_STEP not in", values, "upWeightStep");
            return (Criteria) this;
        }

        public Criteria andUpWeightStepBetween(BigDecimal value1, BigDecimal value2) {
            addCriterion("UP_WEIGHT_STEP between", value1, value2, "upWeightStep");
            return (Criteria) this;
        }

        public Criteria andUpWeightStepNotBetween(BigDecimal value1, BigDecimal value2) {
            addCriterion("UP_WEIGHT_STEP not between", value1, value2, "upWeightStep");
            return (Criteria) this;
        }

        public Criteria andUpDecrease1IsNull() {
            addCriterion("UP_DECREASE_1 is null");
            return (Criteria) this;
        }

        public Criteria andUpDecrease1IsNotNull() {
            addCriterion("UP_DECREASE_1 is not null");
            return (Criteria) this;
        }

        public Criteria andUpDecrease1EqualTo(BigDecimal value) {
            addCriterion("UP_DECREASE_1 =", value, "upDecrease1");
            return (Criteria) this;
        }

        public Criteria andUpDecrease1NotEqualTo(BigDecimal value) {
            addCriterion("UP_DECREASE_1 <>", value, "upDecrease1");
            return (Criteria) this;
        }

        public Criteria andUpDecrease1GreaterThan(BigDecimal value) {
            addCriterion("UP_DECREASE_1 >", value, "upDecrease1");
            return (Criteria) this;
        }

        public Criteria andUpDecrease1GreaterThanOrEqualTo(BigDecimal value) {
            addCriterion("UP_DECREASE_1 >=", value, "upDecrease1");
            return (Criteria) this;
        }

        public Criteria andUpDecrease1LessThan(BigDecimal value) {
            addCriterion("UP_DECREASE_1 <", value, "upDecrease1");
            return (Criteria) this;
        }

        public Criteria andUpDecrease1LessThanOrEqualTo(BigDecimal value) {
            addCriterion("UP_DECREASE_1 <=", value, "upDecrease1");
            return (Criteria) this;
        }

        public Criteria andUpDecrease1In(List<BigDecimal> values) {
            addCriterion("UP_DECREASE_1 in", values, "upDecrease1");
            return (Criteria) this;
        }

        public Criteria andUpDecrease1NotIn(List<BigDecimal> values) {
            addCriterion("UP_DECREASE_1 not in", values, "upDecrease1");
            return (Criteria) this;
        }

        public Criteria andUpDecrease1Between(BigDecimal value1, BigDecimal value2) {
            addCriterion("UP_DECREASE_1 between", value1, value2, "upDecrease1");
            return (Criteria) this;
        }

        public Criteria andUpDecrease1NotBetween(BigDecimal value1, BigDecimal value2) {
            addCriterion("UP_DECREASE_1 not between", value1, value2, "upDecrease1");
            return (Criteria) this;
        }

        public Criteria andUpDecrease2IsNull() {
            addCriterion("UP_DECREASE_2 is null");
            return (Criteria) this;
        }

        public Criteria andUpDecrease2IsNotNull() {
            addCriterion("UP_DECREASE_2 is not null");
            return (Criteria) this;
        }

        public Criteria andUpDecrease2EqualTo(BigDecimal value) {
            addCriterion("UP_DECREASE_2 =", value, "upDecrease2");
            return (Criteria) this;
        }

        public Criteria andUpDecrease2NotEqualTo(BigDecimal value) {
            addCriterion("UP_DECREASE_2 <>", value, "upDecrease2");
            return (Criteria) this;
        }

        public Criteria andUpDecrease2GreaterThan(BigDecimal value) {
            addCriterion("UP_DECREASE_2 >", value, "upDecrease2");
            return (Criteria) this;
        }

        public Criteria andUpDecrease2GreaterThanOrEqualTo(BigDecimal value) {
            addCriterion("UP_DECREASE_2 >=", value, "upDecrease2");
            return (Criteria) this;
        }

        public Criteria andUpDecrease2LessThan(BigDecimal value) {
            addCriterion("UP_DECREASE_2 <", value, "upDecrease2");
            return (Criteria) this;
        }

        public Criteria andUpDecrease2LessThanOrEqualTo(BigDecimal value) {
            addCriterion("UP_DECREASE_2 <=", value, "upDecrease2");
            return (Criteria) this;
        }

        public Criteria andUpDecrease2In(List<BigDecimal> values) {
            addCriterion("UP_DECREASE_2 in", values, "upDecrease2");
            return (Criteria) this;
        }

        public Criteria andUpDecrease2NotIn(List<BigDecimal> values) {
            addCriterion("UP_DECREASE_2 not in", values, "upDecrease2");
            return (Criteria) this;
        }

        public Criteria andUpDecrease2Between(BigDecimal value1, BigDecimal value2) {
            addCriterion("UP_DECREASE_2 between", value1, value2, "upDecrease2");
            return (Criteria) this;
        }

        public Criteria andUpDecrease2NotBetween(BigDecimal value1, BigDecimal value2) {
            addCriterion("UP_DECREASE_2 not between", value1, value2, "upDecrease2");
            return (Criteria) this;
        }

        public Criteria andUpDecreaseStepIsNull() {
            addCriterion("UP_DECREASE_STEP is null");
            return (Criteria) this;
        }

        public Criteria andUpDecreaseStepIsNotNull() {
            addCriterion("UP_DECREASE_STEP is not null");
            return (Criteria) this;
        }

        public Criteria andUpDecreaseStepEqualTo(BigDecimal value) {
            addCriterion("UP_DECREASE_STEP =", value, "upDecreaseStep");
            return (Criteria) this;
        }

        public Criteria andUpDecreaseStepNotEqualTo(BigDecimal value) {
            addCriterion("UP_DECREASE_STEP <>", value, "upDecreaseStep");
            return (Criteria) this;
        }

        public Criteria andUpDecreaseStepGreaterThan(BigDecimal value) {
            addCriterion("UP_DECREASE_STEP >", value, "upDecreaseStep");
            return (Criteria) this;
        }

        public Criteria andUpDecreaseStepGreaterThanOrEqualTo(BigDecimal value) {
            addCriterion("UP_DECREASE_STEP >=", value, "upDecreaseStep");
            return (Criteria) this;
        }

        public Criteria andUpDecreaseStepLessThan(BigDecimal value) {
            addCriterion("UP_DECREASE_STEP <", value, "upDecreaseStep");
            return (Criteria) this;
        }

        public Criteria andUpDecreaseStepLessThanOrEqualTo(BigDecimal value) {
            addCriterion("UP_DECREASE_STEP <=", value, "upDecreaseStep");
            return (Criteria) this;
        }

        public Criteria andUpDecreaseStepIn(List<BigDecimal> values) {
            addCriterion("UP_DECREASE_STEP in", values, "upDecreaseStep");
            return (Criteria) this;
        }

        public Criteria andUpDecreaseStepNotIn(List<BigDecimal> values) {
            addCriterion("UP_DECREASE_STEP not in", values, "upDecreaseStep");
            return (Criteria) this;
        }

        public Criteria andUpDecreaseStepBetween(BigDecimal value1, BigDecimal value2) {
            addCriterion("UP_DECREASE_STEP between", value1, value2, "upDecreaseStep");
            return (Criteria) this;
        }

        public Criteria andUpDecreaseStepNotBetween(BigDecimal value1, BigDecimal value2) {
            addCriterion("UP_DECREASE_STEP not between", value1, value2, "upDecreaseStep");
            return (Criteria) this;
        }

        public Criteria andUpPriceIncremental1IsNull() {
            addCriterion("UP_PRICE_INCREMENTAL_1 is null");
            return (Criteria) this;
        }

        public Criteria andUpPriceIncremental1IsNotNull() {
            addCriterion("UP_PRICE_INCREMENTAL_1 is not null");
            return (Criteria) this;
        }

        public Criteria andUpPriceIncremental1EqualTo(BigDecimal value) {
            addCriterion("UP_PRICE_INCREMENTAL_1 =", value, "upPriceIncremental1");
            return (Criteria) this;
        }

        public Criteria andUpPriceIncremental1NotEqualTo(BigDecimal value) {
            addCriterion("UP_PRICE_INCREMENTAL_1 <>", value, "upPriceIncremental1");
            return (Criteria) this;
        }

        public Criteria andUpPriceIncremental1GreaterThan(BigDecimal value) {
            addCriterion("UP_PRICE_INCREMENTAL_1 >", value, "upPriceIncremental1");
            return (Criteria) this;
        }

        public Criteria andUpPriceIncremental1GreaterThanOrEqualTo(BigDecimal value) {
            addCriterion("UP_PRICE_INCREMENTAL_1 >=", value, "upPriceIncremental1");
            return (Criteria) this;
        }

        public Criteria andUpPriceIncremental1LessThan(BigDecimal value) {
            addCriterion("UP_PRICE_INCREMENTAL_1 <", value, "upPriceIncremental1");
            return (Criteria) this;
        }

        public Criteria andUpPriceIncremental1LessThanOrEqualTo(BigDecimal value) {
            addCriterion("UP_PRICE_INCREMENTAL_1 <=", value, "upPriceIncremental1");
            return (Criteria) this;
        }

        public Criteria andUpPriceIncremental1In(List<BigDecimal> values) {
            addCriterion("UP_PRICE_INCREMENTAL_1 in", values, "upPriceIncremental1");
            return (Criteria) this;
        }

        public Criteria andUpPriceIncremental1NotIn(List<BigDecimal> values) {
            addCriterion("UP_PRICE_INCREMENTAL_1 not in", values, "upPriceIncremental1");
            return (Criteria) this;
        }

        public Criteria andUpPriceIncremental1Between(BigDecimal value1, BigDecimal value2) {
            addCriterion("UP_PRICE_INCREMENTAL_1 between", value1, value2, "upPriceIncremental1");
            return (Criteria) this;
        }

        public Criteria andUpPriceIncremental1NotBetween(BigDecimal value1, BigDecimal value2) {
            addCriterion("UP_PRICE_INCREMENTAL_1 not between", value1, value2, "upPriceIncremental1");
            return (Criteria) this;
        }

        public Criteria andUpPriceIncremental2IsNull() {
            addCriterion("UP_PRICE_INCREMENTAL_2 is null");
            return (Criteria) this;
        }

        public Criteria andUpPriceIncremental2IsNotNull() {
            addCriterion("UP_PRICE_INCREMENTAL_2 is not null");
            return (Criteria) this;
        }

        public Criteria andUpPriceIncremental2EqualTo(BigDecimal value) {
            addCriterion("UP_PRICE_INCREMENTAL_2 =", value, "upPriceIncremental2");
            return (Criteria) this;
        }

        public Criteria andUpPriceIncremental2NotEqualTo(BigDecimal value) {
            addCriterion("UP_PRICE_INCREMENTAL_2 <>", value, "upPriceIncremental2");
            return (Criteria) this;
        }

        public Criteria andUpPriceIncremental2GreaterThan(BigDecimal value) {
            addCriterion("UP_PRICE_INCREMENTAL_2 >", value, "upPriceIncremental2");
            return (Criteria) this;
        }

        public Criteria andUpPriceIncremental2GreaterThanOrEqualTo(BigDecimal value) {
            addCriterion("UP_PRICE_INCREMENTAL_2 >=", value, "upPriceIncremental2");
            return (Criteria) this;
        }

        public Criteria andUpPriceIncremental2LessThan(BigDecimal value) {
            addCriterion("UP_PRICE_INCREMENTAL_2 <", value, "upPriceIncremental2");
            return (Criteria) this;
        }

        public Criteria andUpPriceIncremental2LessThanOrEqualTo(BigDecimal value) {
            addCriterion("UP_PRICE_INCREMENTAL_2 <=", value, "upPriceIncremental2");
            return (Criteria) this;
        }

        public Criteria andUpPriceIncremental2In(List<BigDecimal> values) {
            addCriterion("UP_PRICE_INCREMENTAL_2 in", values, "upPriceIncremental2");
            return (Criteria) this;
        }

        public Criteria andUpPriceIncremental2NotIn(List<BigDecimal> values) {
            addCriterion("UP_PRICE_INCREMENTAL_2 not in", values, "upPriceIncremental2");
            return (Criteria) this;
        }

        public Criteria andUpPriceIncremental2Between(BigDecimal value1, BigDecimal value2) {
            addCriterion("UP_PRICE_INCREMENTAL_2 between", value1, value2, "upPriceIncremental2");
            return (Criteria) this;
        }

        public Criteria andUpPriceIncremental2NotBetween(BigDecimal value1, BigDecimal value2) {
            addCriterion("UP_PRICE_INCREMENTAL_2 not between", value1, value2, "upPriceIncremental2");
            return (Criteria) this;
        }

        public Criteria andUpPriceIncrementalStepIsNull() {
            addCriterion("UP_PRICE_INCREMENTAL_STEP is null");
            return (Criteria) this;
        }

        public Criteria andUpPriceIncrementalStepIsNotNull() {
            addCriterion("UP_PRICE_INCREMENTAL_STEP is not null");
            return (Criteria) this;
        }

        public Criteria andUpPriceIncrementalStepEqualTo(BigDecimal value) {
            addCriterion("UP_PRICE_INCREMENTAL_STEP =", value, "upPriceIncrementalStep");
            return (Criteria) this;
        }

        public Criteria andUpPriceIncrementalStepNotEqualTo(BigDecimal value) {
            addCriterion("UP_PRICE_INCREMENTAL_STEP <>", value, "upPriceIncrementalStep");
            return (Criteria) this;
        }

        public Criteria andUpPriceIncrementalStepGreaterThan(BigDecimal value) {
            addCriterion("UP_PRICE_INCREMENTAL_STEP >", value, "upPriceIncrementalStep");
            return (Criteria) this;
        }

        public Criteria andUpPriceIncrementalStepGreaterThanOrEqualTo(BigDecimal value) {
            addCriterion("UP_PRICE_INCREMENTAL_STEP >=", value, "upPriceIncrementalStep");
            return (Criteria) this;
        }

        public Criteria andUpPriceIncrementalStepLessThan(BigDecimal value) {
            addCriterion("UP_PRICE_INCREMENTAL_STEP <", value, "upPriceIncrementalStep");
            return (Criteria) this;
        }

        public Criteria andUpPriceIncrementalStepLessThanOrEqualTo(BigDecimal value) {
            addCriterion("UP_PRICE_INCREMENTAL_STEP <=", value, "upPriceIncrementalStep");
            return (Criteria) this;
        }

        public Criteria andUpPriceIncrementalStepIn(List<BigDecimal> values) {
            addCriterion("UP_PRICE_INCREMENTAL_STEP in", values, "upPriceIncrementalStep");
            return (Criteria) this;
        }

        public Criteria andUpPriceIncrementalStepNotIn(List<BigDecimal> values) {
            addCriterion("UP_PRICE_INCREMENTAL_STEP not in", values, "upPriceIncrementalStep");
            return (Criteria) this;
        }

        public Criteria andUpPriceIncrementalStepBetween(BigDecimal value1, BigDecimal value2) {
            addCriterion("UP_PRICE_INCREMENTAL_STEP between", value1, value2, "upPriceIncrementalStep");
            return (Criteria) this;
        }

        public Criteria andUpPriceIncrementalStepNotBetween(BigDecimal value1, BigDecimal value2) {
            addCriterion("UP_PRICE_INCREMENTAL_STEP not between", value1, value2, "upPriceIncrementalStep");
            return (Criteria) this;
        }

        public Criteria andUpMin1IsNull() {
            addCriterion("UP_MIN_1 is null");
            return (Criteria) this;
        }

        public Criteria andUpMin1IsNotNull() {
            addCriterion("UP_MIN_1 is not null");
            return (Criteria) this;
        }

        public Criteria andUpMin1EqualTo(BigDecimal value) {
            addCriterion("UP_MIN_1 =", value, "upMin1");
            return (Criteria) this;
        }

        public Criteria andUpMin1NotEqualTo(BigDecimal value) {
            addCriterion("UP_MIN_1 <>", value, "upMin1");
            return (Criteria) this;
        }

        public Criteria andUpMin1GreaterThan(BigDecimal value) {
            addCriterion("UP_MIN_1 >", value, "upMin1");
            return (Criteria) this;
        }

        public Criteria andUpMin1GreaterThanOrEqualTo(BigDecimal value) {
            addCriterion("UP_MIN_1 >=", value, "upMin1");
            return (Criteria) this;
        }

        public Criteria andUpMin1LessThan(BigDecimal value) {
            addCriterion("UP_MIN_1 <", value, "upMin1");
            return (Criteria) this;
        }

        public Criteria andUpMin1LessThanOrEqualTo(BigDecimal value) {
            addCriterion("UP_MIN_1 <=", value, "upMin1");
            return (Criteria) this;
        }

        public Criteria andUpMin1In(List<BigDecimal> values) {
            addCriterion("UP_MIN_1 in", values, "upMin1");
            return (Criteria) this;
        }

        public Criteria andUpMin1NotIn(List<BigDecimal> values) {
            addCriterion("UP_MIN_1 not in", values, "upMin1");
            return (Criteria) this;
        }

        public Criteria andUpMin1Between(BigDecimal value1, BigDecimal value2) {
            addCriterion("UP_MIN_1 between", value1, value2, "upMin1");
            return (Criteria) this;
        }

        public Criteria andUpMin1NotBetween(BigDecimal value1, BigDecimal value2) {
            addCriterion("UP_MIN_1 not between", value1, value2, "upMin1");
            return (Criteria) this;
        }

        public Criteria andUpMin2IsNull() {
            addCriterion("UP_MIN_2 is null");
            return (Criteria) this;
        }

        public Criteria andUpMin2IsNotNull() {
            addCriterion("UP_MIN_2 is not null");
            return (Criteria) this;
        }

        public Criteria andUpMin2EqualTo(BigDecimal value) {
            addCriterion("UP_MIN_2 =", value, "upMin2");
            return (Criteria) this;
        }

        public Criteria andUpMin2NotEqualTo(BigDecimal value) {
            addCriterion("UP_MIN_2 <>", value, "upMin2");
            return (Criteria) this;
        }

        public Criteria andUpMin2GreaterThan(BigDecimal value) {
            addCriterion("UP_MIN_2 >", value, "upMin2");
            return (Criteria) this;
        }

        public Criteria andUpMin2GreaterThanOrEqualTo(BigDecimal value) {
            addCriterion("UP_MIN_2 >=", value, "upMin2");
            return (Criteria) this;
        }

        public Criteria andUpMin2LessThan(BigDecimal value) {
            addCriterion("UP_MIN_2 <", value, "upMin2");
            return (Criteria) this;
        }

        public Criteria andUpMin2LessThanOrEqualTo(BigDecimal value) {
            addCriterion("UP_MIN_2 <=", value, "upMin2");
            return (Criteria) this;
        }

        public Criteria andUpMin2In(List<BigDecimal> values) {
            addCriterion("UP_MIN_2 in", values, "upMin2");
            return (Criteria) this;
        }

        public Criteria andUpMin2NotIn(List<BigDecimal> values) {
            addCriterion("UP_MIN_2 not in", values, "upMin2");
            return (Criteria) this;
        }

        public Criteria andUpMin2Between(BigDecimal value1, BigDecimal value2) {
            addCriterion("UP_MIN_2 between", value1, value2, "upMin2");
            return (Criteria) this;
        }

        public Criteria andUpMin2NotBetween(BigDecimal value1, BigDecimal value2) {
            addCriterion("UP_MIN_2 not between", value1, value2, "upMin2");
            return (Criteria) this;
        }

        public Criteria andUpMinStepIsNull() {
            addCriterion("UP_MIN_STEP is null");
            return (Criteria) this;
        }

        public Criteria andUpMinStepIsNotNull() {
            addCriterion("UP_MIN_STEP is not null");
            return (Criteria) this;
        }

        public Criteria andUpMinStepEqualTo(BigDecimal value) {
            addCriterion("UP_MIN_STEP =", value, "upMinStep");
            return (Criteria) this;
        }

        public Criteria andUpMinStepNotEqualTo(BigDecimal value) {
            addCriterion("UP_MIN_STEP <>", value, "upMinStep");
            return (Criteria) this;
        }

        public Criteria andUpMinStepGreaterThan(BigDecimal value) {
            addCriterion("UP_MIN_STEP >", value, "upMinStep");
            return (Criteria) this;
        }

        public Criteria andUpMinStepGreaterThanOrEqualTo(BigDecimal value) {
            addCriterion("UP_MIN_STEP >=", value, "upMinStep");
            return (Criteria) this;
        }

        public Criteria andUpMinStepLessThan(BigDecimal value) {
            addCriterion("UP_MIN_STEP <", value, "upMinStep");
            return (Criteria) this;
        }

        public Criteria andUpMinStepLessThanOrEqualTo(BigDecimal value) {
            addCriterion("UP_MIN_STEP <=", value, "upMinStep");
            return (Criteria) this;
        }

        public Criteria andUpMinStepIn(List<BigDecimal> values) {
            addCriterion("UP_MIN_STEP in", values, "upMinStep");
            return (Criteria) this;
        }

        public Criteria andUpMinStepNotIn(List<BigDecimal> values) {
            addCriterion("UP_MIN_STEP not in", values, "upMinStep");
            return (Criteria) this;
        }

        public Criteria andUpMinStepBetween(BigDecimal value1, BigDecimal value2) {
            addCriterion("UP_MIN_STEP between", value1, value2, "upMinStep");
            return (Criteria) this;
        }

        public Criteria andUpMinStepNotBetween(BigDecimal value1, BigDecimal value2) {
            addCriterion("UP_MIN_STEP not between", value1, value2, "upMinStep");
            return (Criteria) this;
        }

        public Criteria andDownWeight1IsNull() {
            addCriterion("DOWN_WEIGHT_1 is null");
            return (Criteria) this;
        }

        public Criteria andDownWeight1IsNotNull() {
            addCriterion("DOWN_WEIGHT_1 is not null");
            return (Criteria) this;
        }

        public Criteria andDownWeight1EqualTo(BigDecimal value) {
            addCriterion("DOWN_WEIGHT_1 =", value, "downWeight1");
            return (Criteria) this;
        }

        public Criteria andDownWeight1NotEqualTo(BigDecimal value) {
            addCriterion("DOWN_WEIGHT_1 <>", value, "downWeight1");
            return (Criteria) this;
        }

        public Criteria andDownWeight1GreaterThan(BigDecimal value) {
            addCriterion("DOWN_WEIGHT_1 >", value, "downWeight1");
            return (Criteria) this;
        }

        public Criteria andDownWeight1GreaterThanOrEqualTo(BigDecimal value) {
            addCriterion("DOWN_WEIGHT_1 >=", value, "downWeight1");
            return (Criteria) this;
        }

        public Criteria andDownWeight1LessThan(BigDecimal value) {
            addCriterion("DOWN_WEIGHT_1 <", value, "downWeight1");
            return (Criteria) this;
        }

        public Criteria andDownWeight1LessThanOrEqualTo(BigDecimal value) {
            addCriterion("DOWN_WEIGHT_1 <=", value, "downWeight1");
            return (Criteria) this;
        }

        public Criteria andDownWeight1In(List<BigDecimal> values) {
            addCriterion("DOWN_WEIGHT_1 in", values, "downWeight1");
            return (Criteria) this;
        }

        public Criteria andDownWeight1NotIn(List<BigDecimal> values) {
            addCriterion("DOWN_WEIGHT_1 not in", values, "downWeight1");
            return (Criteria) this;
        }

        public Criteria andDownWeight1Between(BigDecimal value1, BigDecimal value2) {
            addCriterion("DOWN_WEIGHT_1 between", value1, value2, "downWeight1");
            return (Criteria) this;
        }

        public Criteria andDownWeight1NotBetween(BigDecimal value1, BigDecimal value2) {
            addCriterion("DOWN_WEIGHT_1 not between", value1, value2, "downWeight1");
            return (Criteria) this;
        }

        public Criteria andDownWeight2IsNull() {
            addCriterion("DOWN_WEIGHT_2 is null");
            return (Criteria) this;
        }

        public Criteria andDownWeight2IsNotNull() {
            addCriterion("DOWN_WEIGHT_2 is not null");
            return (Criteria) this;
        }

        public Criteria andDownWeight2EqualTo(BigDecimal value) {
            addCriterion("DOWN_WEIGHT_2 =", value, "downWeight2");
            return (Criteria) this;
        }

        public Criteria andDownWeight2NotEqualTo(BigDecimal value) {
            addCriterion("DOWN_WEIGHT_2 <>", value, "downWeight2");
            return (Criteria) this;
        }

        public Criteria andDownWeight2GreaterThan(BigDecimal value) {
            addCriterion("DOWN_WEIGHT_2 >", value, "downWeight2");
            return (Criteria) this;
        }

        public Criteria andDownWeight2GreaterThanOrEqualTo(BigDecimal value) {
            addCriterion("DOWN_WEIGHT_2 >=", value, "downWeight2");
            return (Criteria) this;
        }

        public Criteria andDownWeight2LessThan(BigDecimal value) {
            addCriterion("DOWN_WEIGHT_2 <", value, "downWeight2");
            return (Criteria) this;
        }

        public Criteria andDownWeight2LessThanOrEqualTo(BigDecimal value) {
            addCriterion("DOWN_WEIGHT_2 <=", value, "downWeight2");
            return (Criteria) this;
        }

        public Criteria andDownWeight2In(List<BigDecimal> values) {
            addCriterion("DOWN_WEIGHT_2 in", values, "downWeight2");
            return (Criteria) this;
        }

        public Criteria andDownWeight2NotIn(List<BigDecimal> values) {
            addCriterion("DOWN_WEIGHT_2 not in", values, "downWeight2");
            return (Criteria) this;
        }

        public Criteria andDownWeight2Between(BigDecimal value1, BigDecimal value2) {
            addCriterion("DOWN_WEIGHT_2 between", value1, value2, "downWeight2");
            return (Criteria) this;
        }

        public Criteria andDownWeight2NotBetween(BigDecimal value1, BigDecimal value2) {
            addCriterion("DOWN_WEIGHT_2 not between", value1, value2, "downWeight2");
            return (Criteria) this;
        }

        public Criteria andDownWeightStepIsNull() {
            addCriterion("DOWN_WEIGHT_STEP is null");
            return (Criteria) this;
        }

        public Criteria andDownWeightStepIsNotNull() {
            addCriterion("DOWN_WEIGHT_STEP is not null");
            return (Criteria) this;
        }

        public Criteria andDownWeightStepEqualTo(BigDecimal value) {
            addCriterion("DOWN_WEIGHT_STEP =", value, "downWeightStep");
            return (Criteria) this;
        }

        public Criteria andDownWeightStepNotEqualTo(BigDecimal value) {
            addCriterion("DOWN_WEIGHT_STEP <>", value, "downWeightStep");
            return (Criteria) this;
        }

        public Criteria andDownWeightStepGreaterThan(BigDecimal value) {
            addCriterion("DOWN_WEIGHT_STEP >", value, "downWeightStep");
            return (Criteria) this;
        }

        public Criteria andDownWeightStepGreaterThanOrEqualTo(BigDecimal value) {
            addCriterion("DOWN_WEIGHT_STEP >=", value, "downWeightStep");
            return (Criteria) this;
        }

        public Criteria andDownWeightStepLessThan(BigDecimal value) {
            addCriterion("DOWN_WEIGHT_STEP <", value, "downWeightStep");
            return (Criteria) this;
        }

        public Criteria andDownWeightStepLessThanOrEqualTo(BigDecimal value) {
            addCriterion("DOWN_WEIGHT_STEP <=", value, "downWeightStep");
            return (Criteria) this;
        }

        public Criteria andDownWeightStepIn(List<BigDecimal> values) {
            addCriterion("DOWN_WEIGHT_STEP in", values, "downWeightStep");
            return (Criteria) this;
        }

        public Criteria andDownWeightStepNotIn(List<BigDecimal> values) {
            addCriterion("DOWN_WEIGHT_STEP not in", values, "downWeightStep");
            return (Criteria) this;
        }

        public Criteria andDownWeightStepBetween(BigDecimal value1, BigDecimal value2) {
            addCriterion("DOWN_WEIGHT_STEP between", value1, value2, "downWeightStep");
            return (Criteria) this;
        }

        public Criteria andDownWeightStepNotBetween(BigDecimal value1, BigDecimal value2) {
            addCriterion("DOWN_WEIGHT_STEP not between", value1, value2, "downWeightStep");
            return (Criteria) this;
        }

        public Criteria andDownCallback1IsNull() {
            addCriterion("DOWN_CALLBACK_1 is null");
            return (Criteria) this;
        }

        public Criteria andDownCallback1IsNotNull() {
            addCriterion("DOWN_CALLBACK_1 is not null");
            return (Criteria) this;
        }

        public Criteria andDownCallback1EqualTo(BigDecimal value) {
            addCriterion("DOWN_CALLBACK_1 =", value, "downCallback1");
            return (Criteria) this;
        }

        public Criteria andDownCallback1NotEqualTo(BigDecimal value) {
            addCriterion("DOWN_CALLBACK_1 <>", value, "downCallback1");
            return (Criteria) this;
        }

        public Criteria andDownCallback1GreaterThan(BigDecimal value) {
            addCriterion("DOWN_CALLBACK_1 >", value, "downCallback1");
            return (Criteria) this;
        }

        public Criteria andDownCallback1GreaterThanOrEqualTo(BigDecimal value) {
            addCriterion("DOWN_CALLBACK_1 >=", value, "downCallback1");
            return (Criteria) this;
        }

        public Criteria andDownCallback1LessThan(BigDecimal value) {
            addCriterion("DOWN_CALLBACK_1 <", value, "downCallback1");
            return (Criteria) this;
        }

        public Criteria andDownCallback1LessThanOrEqualTo(BigDecimal value) {
            addCriterion("DOWN_CALLBACK_1 <=", value, "downCallback1");
            return (Criteria) this;
        }

        public Criteria andDownCallback1In(List<BigDecimal> values) {
            addCriterion("DOWN_CALLBACK_1 in", values, "downCallback1");
            return (Criteria) this;
        }

        public Criteria andDownCallback1NotIn(List<BigDecimal> values) {
            addCriterion("DOWN_CALLBACK_1 not in", values, "downCallback1");
            return (Criteria) this;
        }

        public Criteria andDownCallback1Between(BigDecimal value1, BigDecimal value2) {
            addCriterion("DOWN_CALLBACK_1 between", value1, value2, "downCallback1");
            return (Criteria) this;
        }

        public Criteria andDownCallback1NotBetween(BigDecimal value1, BigDecimal value2) {
            addCriterion("DOWN_CALLBACK_1 not between", value1, value2, "downCallback1");
            return (Criteria) this;
        }

        public Criteria andDownCallback2IsNull() {
            addCriterion("DOWN_CALLBACK_2 is null");
            return (Criteria) this;
        }

        public Criteria andDownCallback2IsNotNull() {
            addCriterion("DOWN_CALLBACK_2 is not null");
            return (Criteria) this;
        }

        public Criteria andDownCallback2EqualTo(BigDecimal value) {
            addCriterion("DOWN_CALLBACK_2 =", value, "downCallback2");
            return (Criteria) this;
        }

        public Criteria andDownCallback2NotEqualTo(BigDecimal value) {
            addCriterion("DOWN_CALLBACK_2 <>", value, "downCallback2");
            return (Criteria) this;
        }

        public Criteria andDownCallback2GreaterThan(BigDecimal value) {
            addCriterion("DOWN_CALLBACK_2 >", value, "downCallback2");
            return (Criteria) this;
        }

        public Criteria andDownCallback2GreaterThanOrEqualTo(BigDecimal value) {
            addCriterion("DOWN_CALLBACK_2 >=", value, "downCallback2");
            return (Criteria) this;
        }

        public Criteria andDownCallback2LessThan(BigDecimal value) {
            addCriterion("DOWN_CALLBACK_2 <", value, "downCallback2");
            return (Criteria) this;
        }

        public Criteria andDownCallback2LessThanOrEqualTo(BigDecimal value) {
            addCriterion("DOWN_CALLBACK_2 <=", value, "downCallback2");
            return (Criteria) this;
        }

        public Criteria andDownCallback2In(List<BigDecimal> values) {
            addCriterion("DOWN_CALLBACK_2 in", values, "downCallback2");
            return (Criteria) this;
        }

        public Criteria andDownCallback2NotIn(List<BigDecimal> values) {
            addCriterion("DOWN_CALLBACK_2 not in", values, "downCallback2");
            return (Criteria) this;
        }

        public Criteria andDownCallback2Between(BigDecimal value1, BigDecimal value2) {
            addCriterion("DOWN_CALLBACK_2 between", value1, value2, "downCallback2");
            return (Criteria) this;
        }

        public Criteria andDownCallback2NotBetween(BigDecimal value1, BigDecimal value2) {
            addCriterion("DOWN_CALLBACK_2 not between", value1, value2, "downCallback2");
            return (Criteria) this;
        }

        public Criteria andDownCallbackStepIsNull() {
            addCriterion("DOWN_CALLBACK_STEP is null");
            return (Criteria) this;
        }

        public Criteria andDownCallbackStepIsNotNull() {
            addCriterion("DOWN_CALLBACK_STEP is not null");
            return (Criteria) this;
        }

        public Criteria andDownCallbackStepEqualTo(BigDecimal value) {
            addCriterion("DOWN_CALLBACK_STEP =", value, "downCallbackStep");
            return (Criteria) this;
        }

        public Criteria andDownCallbackStepNotEqualTo(BigDecimal value) {
            addCriterion("DOWN_CALLBACK_STEP <>", value, "downCallbackStep");
            return (Criteria) this;
        }

        public Criteria andDownCallbackStepGreaterThan(BigDecimal value) {
            addCriterion("DOWN_CALLBACK_STEP >", value, "downCallbackStep");
            return (Criteria) this;
        }

        public Criteria andDownCallbackStepGreaterThanOrEqualTo(BigDecimal value) {
            addCriterion("DOWN_CALLBACK_STEP >=", value, "downCallbackStep");
            return (Criteria) this;
        }

        public Criteria andDownCallbackStepLessThan(BigDecimal value) {
            addCriterion("DOWN_CALLBACK_STEP <", value, "downCallbackStep");
            return (Criteria) this;
        }

        public Criteria andDownCallbackStepLessThanOrEqualTo(BigDecimal value) {
            addCriterion("DOWN_CALLBACK_STEP <=", value, "downCallbackStep");
            return (Criteria) this;
        }

        public Criteria andDownCallbackStepIn(List<BigDecimal> values) {
            addCriterion("DOWN_CALLBACK_STEP in", values, "downCallbackStep");
            return (Criteria) this;
        }

        public Criteria andDownCallbackStepNotIn(List<BigDecimal> values) {
            addCriterion("DOWN_CALLBACK_STEP not in", values, "downCallbackStep");
            return (Criteria) this;
        }

        public Criteria andDownCallbackStepBetween(BigDecimal value1, BigDecimal value2) {
            addCriterion("DOWN_CALLBACK_STEP between", value1, value2, "downCallbackStep");
            return (Criteria) this;
        }

        public Criteria andDownCallbackStepNotBetween(BigDecimal value1, BigDecimal value2) {
            addCriterion("DOWN_CALLBACK_STEP not between", value1, value2, "downCallbackStep");
            return (Criteria) this;
        }

        public Criteria andDownIncremental1IsNull() {
            addCriterion("DOWN_INCREMENTAL_1 is null");
            return (Criteria) this;
        }

        public Criteria andDownIncremental1IsNotNull() {
            addCriterion("DOWN_INCREMENTAL_1 is not null");
            return (Criteria) this;
        }

        public Criteria andDownIncremental1EqualTo(BigDecimal value) {
            addCriterion("DOWN_INCREMENTAL_1 =", value, "downIncremental1");
            return (Criteria) this;
        }

        public Criteria andDownIncremental1NotEqualTo(BigDecimal value) {
            addCriterion("DOWN_INCREMENTAL_1 <>", value, "downIncremental1");
            return (Criteria) this;
        }

        public Criteria andDownIncremental1GreaterThan(BigDecimal value) {
            addCriterion("DOWN_INCREMENTAL_1 >", value, "downIncremental1");
            return (Criteria) this;
        }

        public Criteria andDownIncremental1GreaterThanOrEqualTo(BigDecimal value) {
            addCriterion("DOWN_INCREMENTAL_1 >=", value, "downIncremental1");
            return (Criteria) this;
        }

        public Criteria andDownIncremental1LessThan(BigDecimal value) {
            addCriterion("DOWN_INCREMENTAL_1 <", value, "downIncremental1");
            return (Criteria) this;
        }

        public Criteria andDownIncremental1LessThanOrEqualTo(BigDecimal value) {
            addCriterion("DOWN_INCREMENTAL_1 <=", value, "downIncremental1");
            return (Criteria) this;
        }

        public Criteria andDownIncremental1In(List<BigDecimal> values) {
            addCriterion("DOWN_INCREMENTAL_1 in", values, "downIncremental1");
            return (Criteria) this;
        }

        public Criteria andDownIncremental1NotIn(List<BigDecimal> values) {
            addCriterion("DOWN_INCREMENTAL_1 not in", values, "downIncremental1");
            return (Criteria) this;
        }

        public Criteria andDownIncremental1Between(BigDecimal value1, BigDecimal value2) {
            addCriterion("DOWN_INCREMENTAL_1 between", value1, value2, "downIncremental1");
            return (Criteria) this;
        }

        public Criteria andDownIncremental1NotBetween(BigDecimal value1, BigDecimal value2) {
            addCriterion("DOWN_INCREMENTAL_1 not between", value1, value2, "downIncremental1");
            return (Criteria) this;
        }

        public Criteria andDownIncremental2IsNull() {
            addCriterion("DOWN_INCREMENTAL_2 is null");
            return (Criteria) this;
        }

        public Criteria andDownIncremental2IsNotNull() {
            addCriterion("DOWN_INCREMENTAL_2 is not null");
            return (Criteria) this;
        }

        public Criteria andDownIncremental2EqualTo(BigDecimal value) {
            addCriterion("DOWN_INCREMENTAL_2 =", value, "downIncremental2");
            return (Criteria) this;
        }

        public Criteria andDownIncremental2NotEqualTo(BigDecimal value) {
            addCriterion("DOWN_INCREMENTAL_2 <>", value, "downIncremental2");
            return (Criteria) this;
        }

        public Criteria andDownIncremental2GreaterThan(BigDecimal value) {
            addCriterion("DOWN_INCREMENTAL_2 >", value, "downIncremental2");
            return (Criteria) this;
        }

        public Criteria andDownIncremental2GreaterThanOrEqualTo(BigDecimal value) {
            addCriterion("DOWN_INCREMENTAL_2 >=", value, "downIncremental2");
            return (Criteria) this;
        }

        public Criteria andDownIncremental2LessThan(BigDecimal value) {
            addCriterion("DOWN_INCREMENTAL_2 <", value, "downIncremental2");
            return (Criteria) this;
        }

        public Criteria andDownIncremental2LessThanOrEqualTo(BigDecimal value) {
            addCriterion("DOWN_INCREMENTAL_2 <=", value, "downIncremental2");
            return (Criteria) this;
        }

        public Criteria andDownIncremental2In(List<BigDecimal> values) {
            addCriterion("DOWN_INCREMENTAL_2 in", values, "downIncremental2");
            return (Criteria) this;
        }

        public Criteria andDownIncremental2NotIn(List<BigDecimal> values) {
            addCriterion("DOWN_INCREMENTAL_2 not in", values, "downIncremental2");
            return (Criteria) this;
        }

        public Criteria andDownIncremental2Between(BigDecimal value1, BigDecimal value2) {
            addCriterion("DOWN_INCREMENTAL_2 between", value1, value2, "downIncremental2");
            return (Criteria) this;
        }

        public Criteria andDownIncremental2NotBetween(BigDecimal value1, BigDecimal value2) {
            addCriterion("DOWN_INCREMENTAL_2 not between", value1, value2, "downIncremental2");
            return (Criteria) this;
        }

        public Criteria andDownIncrementalStepIsNull() {
            addCriterion("DOWN_INCREMENTAL_STEP is null");
            return (Criteria) this;
        }

        public Criteria andDownIncrementalStepIsNotNull() {
            addCriterion("DOWN_INCREMENTAL_STEP is not null");
            return (Criteria) this;
        }

        public Criteria andDownIncrementalStepEqualTo(BigDecimal value) {
            addCriterion("DOWN_INCREMENTAL_STEP =", value, "downIncrementalStep");
            return (Criteria) this;
        }

        public Criteria andDownIncrementalStepNotEqualTo(BigDecimal value) {
            addCriterion("DOWN_INCREMENTAL_STEP <>", value, "downIncrementalStep");
            return (Criteria) this;
        }

        public Criteria andDownIncrementalStepGreaterThan(BigDecimal value) {
            addCriterion("DOWN_INCREMENTAL_STEP >", value, "downIncrementalStep");
            return (Criteria) this;
        }

        public Criteria andDownIncrementalStepGreaterThanOrEqualTo(BigDecimal value) {
            addCriterion("DOWN_INCREMENTAL_STEP >=", value, "downIncrementalStep");
            return (Criteria) this;
        }

        public Criteria andDownIncrementalStepLessThan(BigDecimal value) {
            addCriterion("DOWN_INCREMENTAL_STEP <", value, "downIncrementalStep");
            return (Criteria) this;
        }

        public Criteria andDownIncrementalStepLessThanOrEqualTo(BigDecimal value) {
            addCriterion("DOWN_INCREMENTAL_STEP <=", value, "downIncrementalStep");
            return (Criteria) this;
        }

        public Criteria andDownIncrementalStepIn(List<BigDecimal> values) {
            addCriterion("DOWN_INCREMENTAL_STEP in", values, "downIncrementalStep");
            return (Criteria) this;
        }

        public Criteria andDownIncrementalStepNotIn(List<BigDecimal> values) {
            addCriterion("DOWN_INCREMENTAL_STEP not in", values, "downIncrementalStep");
            return (Criteria) this;
        }

        public Criteria andDownIncrementalStepBetween(BigDecimal value1, BigDecimal value2) {
            addCriterion("DOWN_INCREMENTAL_STEP between", value1, value2, "downIncrementalStep");
            return (Criteria) this;
        }

        public Criteria andDownIncrementalStepNotBetween(BigDecimal value1, BigDecimal value2) {
            addCriterion("DOWN_INCREMENTAL_STEP not between", value1, value2, "downIncrementalStep");
            return (Criteria) this;
        }

        public Criteria andDownPriceIncremental1IsNull() {
            addCriterion("DOWN_PRICE_INCREMENTAL_1 is null");
            return (Criteria) this;
        }

        public Criteria andDownPriceIncremental1IsNotNull() {
            addCriterion("DOWN_PRICE_INCREMENTAL_1 is not null");
            return (Criteria) this;
        }

        public Criteria andDownPriceIncremental1EqualTo(BigDecimal value) {
            addCriterion("DOWN_PRICE_INCREMENTAL_1 =", value, "downPriceIncremental1");
            return (Criteria) this;
        }

        public Criteria andDownPriceIncremental1NotEqualTo(BigDecimal value) {
            addCriterion("DOWN_PRICE_INCREMENTAL_1 <>", value, "downPriceIncremental1");
            return (Criteria) this;
        }

        public Criteria andDownPriceIncremental1GreaterThan(BigDecimal value) {
            addCriterion("DOWN_PRICE_INCREMENTAL_1 >", value, "downPriceIncremental1");
            return (Criteria) this;
        }

        public Criteria andDownPriceIncremental1GreaterThanOrEqualTo(BigDecimal value) {
            addCriterion("DOWN_PRICE_INCREMENTAL_1 >=", value, "downPriceIncremental1");
            return (Criteria) this;
        }

        public Criteria andDownPriceIncremental1LessThan(BigDecimal value) {
            addCriterion("DOWN_PRICE_INCREMENTAL_1 <", value, "downPriceIncremental1");
            return (Criteria) this;
        }

        public Criteria andDownPriceIncremental1LessThanOrEqualTo(BigDecimal value) {
            addCriterion("DOWN_PRICE_INCREMENTAL_1 <=", value, "downPriceIncremental1");
            return (Criteria) this;
        }

        public Criteria andDownPriceIncremental1In(List<BigDecimal> values) {
            addCriterion("DOWN_PRICE_INCREMENTAL_1 in", values, "downPriceIncremental1");
            return (Criteria) this;
        }

        public Criteria andDownPriceIncremental1NotIn(List<BigDecimal> values) {
            addCriterion("DOWN_PRICE_INCREMENTAL_1 not in", values, "downPriceIncremental1");
            return (Criteria) this;
        }

        public Criteria andDownPriceIncremental1Between(BigDecimal value1, BigDecimal value2) {
            addCriterion("DOWN_PRICE_INCREMENTAL_1 between", value1, value2, "downPriceIncremental1");
            return (Criteria) this;
        }

        public Criteria andDownPriceIncremental1NotBetween(BigDecimal value1, BigDecimal value2) {
            addCriterion("DOWN_PRICE_INCREMENTAL_1 not between", value1, value2, "downPriceIncremental1");
            return (Criteria) this;
        }

        public Criteria andDownPriceIncremental2IsNull() {
            addCriterion("DOWN_PRICE_INCREMENTAL_2 is null");
            return (Criteria) this;
        }

        public Criteria andDownPriceIncremental2IsNotNull() {
            addCriterion("DOWN_PRICE_INCREMENTAL_2 is not null");
            return (Criteria) this;
        }

        public Criteria andDownPriceIncremental2EqualTo(BigDecimal value) {
            addCriterion("DOWN_PRICE_INCREMENTAL_2 =", value, "downPriceIncremental2");
            return (Criteria) this;
        }

        public Criteria andDownPriceIncremental2NotEqualTo(BigDecimal value) {
            addCriterion("DOWN_PRICE_INCREMENTAL_2 <>", value, "downPriceIncremental2");
            return (Criteria) this;
        }

        public Criteria andDownPriceIncremental2GreaterThan(BigDecimal value) {
            addCriterion("DOWN_PRICE_INCREMENTAL_2 >", value, "downPriceIncremental2");
            return (Criteria) this;
        }

        public Criteria andDownPriceIncremental2GreaterThanOrEqualTo(BigDecimal value) {
            addCriterion("DOWN_PRICE_INCREMENTAL_2 >=", value, "downPriceIncremental2");
            return (Criteria) this;
        }

        public Criteria andDownPriceIncremental2LessThan(BigDecimal value) {
            addCriterion("DOWN_PRICE_INCREMENTAL_2 <", value, "downPriceIncremental2");
            return (Criteria) this;
        }

        public Criteria andDownPriceIncremental2LessThanOrEqualTo(BigDecimal value) {
            addCriterion("DOWN_PRICE_INCREMENTAL_2 <=", value, "downPriceIncremental2");
            return (Criteria) this;
        }

        public Criteria andDownPriceIncremental2In(List<BigDecimal> values) {
            addCriterion("DOWN_PRICE_INCREMENTAL_2 in", values, "downPriceIncremental2");
            return (Criteria) this;
        }

        public Criteria andDownPriceIncremental2NotIn(List<BigDecimal> values) {
            addCriterion("DOWN_PRICE_INCREMENTAL_2 not in", values, "downPriceIncremental2");
            return (Criteria) this;
        }

        public Criteria andDownPriceIncremental2Between(BigDecimal value1, BigDecimal value2) {
            addCriterion("DOWN_PRICE_INCREMENTAL_2 between", value1, value2, "downPriceIncremental2");
            return (Criteria) this;
        }

        public Criteria andDownPriceIncremental2NotBetween(BigDecimal value1, BigDecimal value2) {
            addCriterion("DOWN_PRICE_INCREMENTAL_2 not between", value1, value2, "downPriceIncremental2");
            return (Criteria) this;
        }

        public Criteria andDownPriceIncrementalStepIsNull() {
            addCriterion("DOWN_PRICE_INCREMENTAL_STEP is null");
            return (Criteria) this;
        }

        public Criteria andDownPriceIncrementalStepIsNotNull() {
            addCriterion("DOWN_PRICE_INCREMENTAL_STEP is not null");
            return (Criteria) this;
        }

        public Criteria andDownPriceIncrementalStepEqualTo(BigDecimal value) {
            addCriterion("DOWN_PRICE_INCREMENTAL_STEP =", value, "downPriceIncrementalStep");
            return (Criteria) this;
        }

        public Criteria andDownPriceIncrementalStepNotEqualTo(BigDecimal value) {
            addCriterion("DOWN_PRICE_INCREMENTAL_STEP <>", value, "downPriceIncrementalStep");
            return (Criteria) this;
        }

        public Criteria andDownPriceIncrementalStepGreaterThan(BigDecimal value) {
            addCriterion("DOWN_PRICE_INCREMENTAL_STEP >", value, "downPriceIncrementalStep");
            return (Criteria) this;
        }

        public Criteria andDownPriceIncrementalStepGreaterThanOrEqualTo(BigDecimal value) {
            addCriterion("DOWN_PRICE_INCREMENTAL_STEP >=", value, "downPriceIncrementalStep");
            return (Criteria) this;
        }

        public Criteria andDownPriceIncrementalStepLessThan(BigDecimal value) {
            addCriterion("DOWN_PRICE_INCREMENTAL_STEP <", value, "downPriceIncrementalStep");
            return (Criteria) this;
        }

        public Criteria andDownPriceIncrementalStepLessThanOrEqualTo(BigDecimal value) {
            addCriterion("DOWN_PRICE_INCREMENTAL_STEP <=", value, "downPriceIncrementalStep");
            return (Criteria) this;
        }

        public Criteria andDownPriceIncrementalStepIn(List<BigDecimal> values) {
            addCriterion("DOWN_PRICE_INCREMENTAL_STEP in", values, "downPriceIncrementalStep");
            return (Criteria) this;
        }

        public Criteria andDownPriceIncrementalStepNotIn(List<BigDecimal> values) {
            addCriterion("DOWN_PRICE_INCREMENTAL_STEP not in", values, "downPriceIncrementalStep");
            return (Criteria) this;
        }

        public Criteria andDownPriceIncrementalStepBetween(BigDecimal value1, BigDecimal value2) {
            addCriterion("DOWN_PRICE_INCREMENTAL_STEP between", value1, value2, "downPriceIncrementalStep");
            return (Criteria) this;
        }

        public Criteria andDownPriceIncrementalStepNotBetween(BigDecimal value1, BigDecimal value2) {
            addCriterion("DOWN_PRICE_INCREMENTAL_STEP not between", value1, value2, "downPriceIncrementalStep");
            return (Criteria) this;
        }

        public Criteria andDownMax1IsNull() {
            addCriterion("DOWN_MAX_1 is null");
            return (Criteria) this;
        }

        public Criteria andDownMax1IsNotNull() {
            addCriterion("DOWN_MAX_1 is not null");
            return (Criteria) this;
        }

        public Criteria andDownMax1EqualTo(BigDecimal value) {
            addCriterion("DOWN_MAX_1 =", value, "downMax1");
            return (Criteria) this;
        }

        public Criteria andDownMax1NotEqualTo(BigDecimal value) {
            addCriterion("DOWN_MAX_1 <>", value, "downMax1");
            return (Criteria) this;
        }

        public Criteria andDownMax1GreaterThan(BigDecimal value) {
            addCriterion("DOWN_MAX_1 >", value, "downMax1");
            return (Criteria) this;
        }

        public Criteria andDownMax1GreaterThanOrEqualTo(BigDecimal value) {
            addCriterion("DOWN_MAX_1 >=", value, "downMax1");
            return (Criteria) this;
        }

        public Criteria andDownMax1LessThan(BigDecimal value) {
            addCriterion("DOWN_MAX_1 <", value, "downMax1");
            return (Criteria) this;
        }

        public Criteria andDownMax1LessThanOrEqualTo(BigDecimal value) {
            addCriterion("DOWN_MAX_1 <=", value, "downMax1");
            return (Criteria) this;
        }

        public Criteria andDownMax1In(List<BigDecimal> values) {
            addCriterion("DOWN_MAX_1 in", values, "downMax1");
            return (Criteria) this;
        }

        public Criteria andDownMax1NotIn(List<BigDecimal> values) {
            addCriterion("DOWN_MAX_1 not in", values, "downMax1");
            return (Criteria) this;
        }

        public Criteria andDownMax1Between(BigDecimal value1, BigDecimal value2) {
            addCriterion("DOWN_MAX_1 between", value1, value2, "downMax1");
            return (Criteria) this;
        }

        public Criteria andDownMax1NotBetween(BigDecimal value1, BigDecimal value2) {
            addCriterion("DOWN_MAX_1 not between", value1, value2, "downMax1");
            return (Criteria) this;
        }

        public Criteria andDownMax2IsNull() {
            addCriterion("DOWN_MAX_2 is null");
            return (Criteria) this;
        }

        public Criteria andDownMax2IsNotNull() {
            addCriterion("DOWN_MAX_2 is not null");
            return (Criteria) this;
        }

        public Criteria andDownMax2EqualTo(BigDecimal value) {
            addCriterion("DOWN_MAX_2 =", value, "downMax2");
            return (Criteria) this;
        }

        public Criteria andDownMax2NotEqualTo(BigDecimal value) {
            addCriterion("DOWN_MAX_2 <>", value, "downMax2");
            return (Criteria) this;
        }

        public Criteria andDownMax2GreaterThan(BigDecimal value) {
            addCriterion("DOWN_MAX_2 >", value, "downMax2");
            return (Criteria) this;
        }

        public Criteria andDownMax2GreaterThanOrEqualTo(BigDecimal value) {
            addCriterion("DOWN_MAX_2 >=", value, "downMax2");
            return (Criteria) this;
        }

        public Criteria andDownMax2LessThan(BigDecimal value) {
            addCriterion("DOWN_MAX_2 <", value, "downMax2");
            return (Criteria) this;
        }

        public Criteria andDownMax2LessThanOrEqualTo(BigDecimal value) {
            addCriterion("DOWN_MAX_2 <=", value, "downMax2");
            return (Criteria) this;
        }

        public Criteria andDownMax2In(List<BigDecimal> values) {
            addCriterion("DOWN_MAX_2 in", values, "downMax2");
            return (Criteria) this;
        }

        public Criteria andDownMax2NotIn(List<BigDecimal> values) {
            addCriterion("DOWN_MAX_2 not in", values, "downMax2");
            return (Criteria) this;
        }

        public Criteria andDownMax2Between(BigDecimal value1, BigDecimal value2) {
            addCriterion("DOWN_MAX_2 between", value1, value2, "downMax2");
            return (Criteria) this;
        }

        public Criteria andDownMax2NotBetween(BigDecimal value1, BigDecimal value2) {
            addCriterion("DOWN_MAX_2 not between", value1, value2, "downMax2");
            return (Criteria) this;
        }

        public Criteria andDownMaxStepIsNull() {
            addCriterion("DOWN_MAX_STEP is null");
            return (Criteria) this;
        }

        public Criteria andDownMaxStepIsNotNull() {
            addCriterion("DOWN_MAX_STEP is not null");
            return (Criteria) this;
        }

        public Criteria andDownMaxStepEqualTo(BigDecimal value) {
            addCriterion("DOWN_MAX_STEP =", value, "downMaxStep");
            return (Criteria) this;
        }

        public Criteria andDownMaxStepNotEqualTo(BigDecimal value) {
            addCriterion("DOWN_MAX_STEP <>", value, "downMaxStep");
            return (Criteria) this;
        }

        public Criteria andDownMaxStepGreaterThan(BigDecimal value) {
            addCriterion("DOWN_MAX_STEP >", value, "downMaxStep");
            return (Criteria) this;
        }

        public Criteria andDownMaxStepGreaterThanOrEqualTo(BigDecimal value) {
            addCriterion("DOWN_MAX_STEP >=", value, "downMaxStep");
            return (Criteria) this;
        }

        public Criteria andDownMaxStepLessThan(BigDecimal value) {
            addCriterion("DOWN_MAX_STEP <", value, "downMaxStep");
            return (Criteria) this;
        }

        public Criteria andDownMaxStepLessThanOrEqualTo(BigDecimal value) {
            addCriterion("DOWN_MAX_STEP <=", value, "downMaxStep");
            return (Criteria) this;
        }

        public Criteria andDownMaxStepIn(List<BigDecimal> values) {
            addCriterion("DOWN_MAX_STEP in", values, "downMaxStep");
            return (Criteria) this;
        }

        public Criteria andDownMaxStepNotIn(List<BigDecimal> values) {
            addCriterion("DOWN_MAX_STEP not in", values, "downMaxStep");
            return (Criteria) this;
        }

        public Criteria andDownMaxStepBetween(BigDecimal value1, BigDecimal value2) {
            addCriterion("DOWN_MAX_STEP between", value1, value2, "downMaxStep");
            return (Criteria) this;
        }

        public Criteria andDownMaxStepNotBetween(BigDecimal value1, BigDecimal value2) {
            addCriterion("DOWN_MAX_STEP not between", value1, value2, "downMaxStep");
            return (Criteria) this;
        }

        public Criteria andStopLose1IsNull() {
            addCriterion("STOP_LOSE_1 is null");
            return (Criteria) this;
        }

        public Criteria andStopLose1IsNotNull() {
            addCriterion("STOP_LOSE_1 is not null");
            return (Criteria) this;
        }

        public Criteria andStopLose1EqualTo(BigDecimal value) {
            addCriterion("STOP_LOSE_1 =", value, "stopLose1");
            return (Criteria) this;
        }

        public Criteria andStopLose1NotEqualTo(BigDecimal value) {
            addCriterion("STOP_LOSE_1 <>", value, "stopLose1");
            return (Criteria) this;
        }

        public Criteria andStopLose1GreaterThan(BigDecimal value) {
            addCriterion("STOP_LOSE_1 >", value, "stopLose1");
            return (Criteria) this;
        }

        public Criteria andStopLose1GreaterThanOrEqualTo(BigDecimal value) {
            addCriterion("STOP_LOSE_1 >=", value, "stopLose1");
            return (Criteria) this;
        }

        public Criteria andStopLose1LessThan(BigDecimal value) {
            addCriterion("STOP_LOSE_1 <", value, "stopLose1");
            return (Criteria) this;
        }

        public Criteria andStopLose1LessThanOrEqualTo(BigDecimal value) {
            addCriterion("STOP_LOSE_1 <=", value, "stopLose1");
            return (Criteria) this;
        }

        public Criteria andStopLose1In(List<BigDecimal> values) {
            addCriterion("STOP_LOSE_1 in", values, "stopLose1");
            return (Criteria) this;
        }

        public Criteria andStopLose1NotIn(List<BigDecimal> values) {
            addCriterion("STOP_LOSE_1 not in", values, "stopLose1");
            return (Criteria) this;
        }

        public Criteria andStopLose1Between(BigDecimal value1, BigDecimal value2) {
            addCriterion("STOP_LOSE_1 between", value1, value2, "stopLose1");
            return (Criteria) this;
        }

        public Criteria andStopLose1NotBetween(BigDecimal value1, BigDecimal value2) {
            addCriterion("STOP_LOSE_1 not between", value1, value2, "stopLose1");
            return (Criteria) this;
        }

        public Criteria andStopLose2IsNull() {
            addCriterion("STOP_LOSE_2 is null");
            return (Criteria) this;
        }

        public Criteria andStopLose2IsNotNull() {
            addCriterion("STOP_LOSE_2 is not null");
            return (Criteria) this;
        }

        public Criteria andStopLose2EqualTo(BigDecimal value) {
            addCriterion("STOP_LOSE_2 =", value, "stopLose2");
            return (Criteria) this;
        }

        public Criteria andStopLose2NotEqualTo(BigDecimal value) {
            addCriterion("STOP_LOSE_2 <>", value, "stopLose2");
            return (Criteria) this;
        }

        public Criteria andStopLose2GreaterThan(BigDecimal value) {
            addCriterion("STOP_LOSE_2 >", value, "stopLose2");
            return (Criteria) this;
        }

        public Criteria andStopLose2GreaterThanOrEqualTo(BigDecimal value) {
            addCriterion("STOP_LOSE_2 >=", value, "stopLose2");
            return (Criteria) this;
        }

        public Criteria andStopLose2LessThan(BigDecimal value) {
            addCriterion("STOP_LOSE_2 <", value, "stopLose2");
            return (Criteria) this;
        }

        public Criteria andStopLose2LessThanOrEqualTo(BigDecimal value) {
            addCriterion("STOP_LOSE_2 <=", value, "stopLose2");
            return (Criteria) this;
        }

        public Criteria andStopLose2In(List<BigDecimal> values) {
            addCriterion("STOP_LOSE_2 in", values, "stopLose2");
            return (Criteria) this;
        }

        public Criteria andStopLose2NotIn(List<BigDecimal> values) {
            addCriterion("STOP_LOSE_2 not in", values, "stopLose2");
            return (Criteria) this;
        }

        public Criteria andStopLose2Between(BigDecimal value1, BigDecimal value2) {
            addCriterion("STOP_LOSE_2 between", value1, value2, "stopLose2");
            return (Criteria) this;
        }

        public Criteria andStopLose2NotBetween(BigDecimal value1, BigDecimal value2) {
            addCriterion("STOP_LOSE_2 not between", value1, value2, "stopLose2");
            return (Criteria) this;
        }

        public Criteria andStopLoseStepIsNull() {
            addCriterion("STOP_LOSE_STEP is null");
            return (Criteria) this;
        }

        public Criteria andStopLoseStepIsNotNull() {
            addCriterion("STOP_LOSE_STEP is not null");
            return (Criteria) this;
        }

        public Criteria andStopLoseStepEqualTo(BigDecimal value) {
            addCriterion("STOP_LOSE_STEP =", value, "stopLoseStep");
            return (Criteria) this;
        }

        public Criteria andStopLoseStepNotEqualTo(BigDecimal value) {
            addCriterion("STOP_LOSE_STEP <>", value, "stopLoseStep");
            return (Criteria) this;
        }

        public Criteria andStopLoseStepGreaterThan(BigDecimal value) {
            addCriterion("STOP_LOSE_STEP >", value, "stopLoseStep");
            return (Criteria) this;
        }

        public Criteria andStopLoseStepGreaterThanOrEqualTo(BigDecimal value) {
            addCriterion("STOP_LOSE_STEP >=", value, "stopLoseStep");
            return (Criteria) this;
        }

        public Criteria andStopLoseStepLessThan(BigDecimal value) {
            addCriterion("STOP_LOSE_STEP <", value, "stopLoseStep");
            return (Criteria) this;
        }

        public Criteria andStopLoseStepLessThanOrEqualTo(BigDecimal value) {
            addCriterion("STOP_LOSE_STEP <=", value, "stopLoseStep");
            return (Criteria) this;
        }

        public Criteria andStopLoseStepIn(List<BigDecimal> values) {
            addCriterion("STOP_LOSE_STEP in", values, "stopLoseStep");
            return (Criteria) this;
        }

        public Criteria andStopLoseStepNotIn(List<BigDecimal> values) {
            addCriterion("STOP_LOSE_STEP not in", values, "stopLoseStep");
            return (Criteria) this;
        }

        public Criteria andStopLoseStepBetween(BigDecimal value1, BigDecimal value2) {
            addCriterion("STOP_LOSE_STEP between", value1, value2, "stopLoseStep");
            return (Criteria) this;
        }

        public Criteria andStopLoseStepNotBetween(BigDecimal value1, BigDecimal value2) {
            addCriterion("STOP_LOSE_STEP not between", value1, value2, "stopLoseStep");
            return (Criteria) this;
        }

        public Criteria andFirstPricePercent1IsNull() {
            addCriterion("FIRST_PRICE_PERCENT_1 is null");
            return (Criteria) this;
        }

        public Criteria andFirstPricePercent1IsNotNull() {
            addCriterion("FIRST_PRICE_PERCENT_1 is not null");
            return (Criteria) this;
        }

        public Criteria andFirstPricePercent1EqualTo(BigDecimal value) {
            addCriterion("FIRST_PRICE_PERCENT_1 =", value, "firstPricePercent1");
            return (Criteria) this;
        }

        public Criteria andFirstPricePercent1NotEqualTo(BigDecimal value) {
            addCriterion("FIRST_PRICE_PERCENT_1 <>", value, "firstPricePercent1");
            return (Criteria) this;
        }

        public Criteria andFirstPricePercent1GreaterThan(BigDecimal value) {
            addCriterion("FIRST_PRICE_PERCENT_1 >", value, "firstPricePercent1");
            return (Criteria) this;
        }

        public Criteria andFirstPricePercent1GreaterThanOrEqualTo(BigDecimal value) {
            addCriterion("FIRST_PRICE_PERCENT_1 >=", value, "firstPricePercent1");
            return (Criteria) this;
        }

        public Criteria andFirstPricePercent1LessThan(BigDecimal value) {
            addCriterion("FIRST_PRICE_PERCENT_1 <", value, "firstPricePercent1");
            return (Criteria) this;
        }

        public Criteria andFirstPricePercent1LessThanOrEqualTo(BigDecimal value) {
            addCriterion("FIRST_PRICE_PERCENT_1 <=", value, "firstPricePercent1");
            return (Criteria) this;
        }

        public Criteria andFirstPricePercent1In(List<BigDecimal> values) {
            addCriterion("FIRST_PRICE_PERCENT_1 in", values, "firstPricePercent1");
            return (Criteria) this;
        }

        public Criteria andFirstPricePercent1NotIn(List<BigDecimal> values) {
            addCriterion("FIRST_PRICE_PERCENT_1 not in", values, "firstPricePercent1");
            return (Criteria) this;
        }

        public Criteria andFirstPricePercent1Between(BigDecimal value1, BigDecimal value2) {
            addCriterion("FIRST_PRICE_PERCENT_1 between", value1, value2, "firstPricePercent1");
            return (Criteria) this;
        }

        public Criteria andFirstPricePercent1NotBetween(BigDecimal value1, BigDecimal value2) {
            addCriterion("FIRST_PRICE_PERCENT_1 not between", value1, value2, "firstPricePercent1");
            return (Criteria) this;
        }

        public Criteria andFirstPricePercent2IsNull() {
            addCriterion("FIRST_PRICE_PERCENT_2 is null");
            return (Criteria) this;
        }

        public Criteria andFirstPricePercent2IsNotNull() {
            addCriterion("FIRST_PRICE_PERCENT_2 is not null");
            return (Criteria) this;
        }

        public Criteria andFirstPricePercent2EqualTo(BigDecimal value) {
            addCriterion("FIRST_PRICE_PERCENT_2 =", value, "firstPricePercent2");
            return (Criteria) this;
        }

        public Criteria andFirstPricePercent2NotEqualTo(BigDecimal value) {
            addCriterion("FIRST_PRICE_PERCENT_2 <>", value, "firstPricePercent2");
            return (Criteria) this;
        }

        public Criteria andFirstPricePercent2GreaterThan(BigDecimal value) {
            addCriterion("FIRST_PRICE_PERCENT_2 >", value, "firstPricePercent2");
            return (Criteria) this;
        }

        public Criteria andFirstPricePercent2GreaterThanOrEqualTo(BigDecimal value) {
            addCriterion("FIRST_PRICE_PERCENT_2 >=", value, "firstPricePercent2");
            return (Criteria) this;
        }

        public Criteria andFirstPricePercent2LessThan(BigDecimal value) {
            addCriterion("FIRST_PRICE_PERCENT_2 <", value, "firstPricePercent2");
            return (Criteria) this;
        }

        public Criteria andFirstPricePercent2LessThanOrEqualTo(BigDecimal value) {
            addCriterion("FIRST_PRICE_PERCENT_2 <=", value, "firstPricePercent2");
            return (Criteria) this;
        }

        public Criteria andFirstPricePercent2In(List<BigDecimal> values) {
            addCriterion("FIRST_PRICE_PERCENT_2 in", values, "firstPricePercent2");
            return (Criteria) this;
        }

        public Criteria andFirstPricePercent2NotIn(List<BigDecimal> values) {
            addCriterion("FIRST_PRICE_PERCENT_2 not in", values, "firstPricePercent2");
            return (Criteria) this;
        }

        public Criteria andFirstPricePercent2Between(BigDecimal value1, BigDecimal value2) {
            addCriterion("FIRST_PRICE_PERCENT_2 between", value1, value2, "firstPricePercent2");
            return (Criteria) this;
        }

        public Criteria andFirstPricePercent2NotBetween(BigDecimal value1, BigDecimal value2) {
            addCriterion("FIRST_PRICE_PERCENT_2 not between", value1, value2, "firstPricePercent2");
            return (Criteria) this;
        }

        public Criteria andFirstPricePercentStepIsNull() {
            addCriterion("FIRST_PRICE_PERCENT_STEP is null");
            return (Criteria) this;
        }

        public Criteria andFirstPricePercentStepIsNotNull() {
            addCriterion("FIRST_PRICE_PERCENT_STEP is not null");
            return (Criteria) this;
        }

        public Criteria andFirstPricePercentStepEqualTo(BigDecimal value) {
            addCriterion("FIRST_PRICE_PERCENT_STEP =", value, "firstPricePercentStep");
            return (Criteria) this;
        }

        public Criteria andFirstPricePercentStepNotEqualTo(BigDecimal value) {
            addCriterion("FIRST_PRICE_PERCENT_STEP <>", value, "firstPricePercentStep");
            return (Criteria) this;
        }

        public Criteria andFirstPricePercentStepGreaterThan(BigDecimal value) {
            addCriterion("FIRST_PRICE_PERCENT_STEP >", value, "firstPricePercentStep");
            return (Criteria) this;
        }

        public Criteria andFirstPricePercentStepGreaterThanOrEqualTo(BigDecimal value) {
            addCriterion("FIRST_PRICE_PERCENT_STEP >=", value, "firstPricePercentStep");
            return (Criteria) this;
        }

        public Criteria andFirstPricePercentStepLessThan(BigDecimal value) {
            addCriterion("FIRST_PRICE_PERCENT_STEP <", value, "firstPricePercentStep");
            return (Criteria) this;
        }

        public Criteria andFirstPricePercentStepLessThanOrEqualTo(BigDecimal value) {
            addCriterion("FIRST_PRICE_PERCENT_STEP <=", value, "firstPricePercentStep");
            return (Criteria) this;
        }

        public Criteria andFirstPricePercentStepIn(List<BigDecimal> values) {
            addCriterion("FIRST_PRICE_PERCENT_STEP in", values, "firstPricePercentStep");
            return (Criteria) this;
        }

        public Criteria andFirstPricePercentStepNotIn(List<BigDecimal> values) {
            addCriterion("FIRST_PRICE_PERCENT_STEP not in", values, "firstPricePercentStep");
            return (Criteria) this;
        }

        public Criteria andFirstPricePercentStepBetween(BigDecimal value1, BigDecimal value2) {
            addCriterion("FIRST_PRICE_PERCENT_STEP between", value1, value2, "firstPricePercentStep");
            return (Criteria) this;
        }

        public Criteria andFirstPricePercentStepNotBetween(BigDecimal value1, BigDecimal value2) {
            addCriterion("FIRST_PRICE_PERCENT_STEP not between", value1, value2, "firstPricePercentStep");
            return (Criteria) this;
        }

        public Criteria andStartTimeIsNull() {
            addCriterion("START_TIME is null");
            return (Criteria) this;
        }

        public Criteria andStartTimeIsNotNull() {
            addCriterion("START_TIME is not null");
            return (Criteria) this;
        }

        public Criteria andStartTimeEqualTo(Date value) {
            addCriterion("START_TIME =", value, "startTime");
            return (Criteria) this;
        }

        public Criteria andStartTimeNotEqualTo(Date value) {
            addCriterion("START_TIME <>", value, "startTime");
            return (Criteria) this;
        }

        public Criteria andStartTimeGreaterThan(Date value) {
            addCriterion("START_TIME >", value, "startTime");
            return (Criteria) this;
        }

        public Criteria andStartTimeGreaterThanOrEqualTo(Date value) {
            addCriterion("START_TIME >=", value, "startTime");
            return (Criteria) this;
        }

        public Criteria andStartTimeLessThan(Date value) {
            addCriterion("START_TIME <", value, "startTime");
            return (Criteria) this;
        }

        public Criteria andStartTimeLessThanOrEqualTo(Date value) {
            addCriterion("START_TIME <=", value, "startTime");
            return (Criteria) this;
        }

        public Criteria andStartTimeIn(List<Date> values) {
            addCriterion("START_TIME in", values, "startTime");
            return (Criteria) this;
        }

        public Criteria andStartTimeNotIn(List<Date> values) {
            addCriterion("START_TIME not in", values, "startTime");
            return (Criteria) this;
        }

        public Criteria andStartTimeBetween(Date value1, Date value2) {
            addCriterion("START_TIME between", value1, value2, "startTime");
            return (Criteria) this;
        }

        public Criteria andStartTimeNotBetween(Date value1, Date value2) {
            addCriterion("START_TIME not between", value1, value2, "startTime");
            return (Criteria) this;
        }

        public Criteria andEndTimeIsNull() {
            addCriterion("END_TIME is null");
            return (Criteria) this;
        }

        public Criteria andEndTimeIsNotNull() {
            addCriterion("END_TIME is not null");
            return (Criteria) this;
        }

        public Criteria andEndTimeEqualTo(Date value) {
            addCriterion("END_TIME =", value, "endTime");
            return (Criteria) this;
        }

        public Criteria andEndTimeNotEqualTo(Date value) {
            addCriterion("END_TIME <>", value, "endTime");
            return (Criteria) this;
        }

        public Criteria andEndTimeGreaterThan(Date value) {
            addCriterion("END_TIME >", value, "endTime");
            return (Criteria) this;
        }

        public Criteria andEndTimeGreaterThanOrEqualTo(Date value) {
            addCriterion("END_TIME >=", value, "endTime");
            return (Criteria) this;
        }

        public Criteria andEndTimeLessThan(Date value) {
            addCriterion("END_TIME <", value, "endTime");
            return (Criteria) this;
        }

        public Criteria andEndTimeLessThanOrEqualTo(Date value) {
            addCriterion("END_TIME <=", value, "endTime");
            return (Criteria) this;
        }

        public Criteria andEndTimeIn(List<Date> values) {
            addCriterion("END_TIME in", values, "endTime");
            return (Criteria) this;
        }

        public Criteria andEndTimeNotIn(List<Date> values) {
            addCriterion("END_TIME not in", values, "endTime");
            return (Criteria) this;
        }

        public Criteria andEndTimeBetween(Date value1, Date value2) {
            addCriterion("END_TIME between", value1, value2, "endTime");
            return (Criteria) this;
        }

        public Criteria andEndTimeNotBetween(Date value1, Date value2) {
            addCriterion("END_TIME not between", value1, value2, "endTime");
            return (Criteria) this;
        }
    }

    public static class Criteria extends GeneratedCriteria {

        protected Criteria() {
            super();
        }
    }

    public static class Criterion {
        private String condition;

        private Object value;

        private Object secondValue;

        private boolean noValue;

        private boolean singleValue;

        private boolean betweenValue;

        private boolean listValue;

        private String typeHandler;

        public String getCondition() {
            return condition;
        }

        public Object getValue() {
            return value;
        }

        public Object getSecondValue() {
            return secondValue;
        }

        public boolean isNoValue() {
            return noValue;
        }

        public boolean isSingleValue() {
            return singleValue;
        }

        public boolean isBetweenValue() {
            return betweenValue;
        }

        public boolean isListValue() {
            return listValue;
        }

        public String getTypeHandler() {
            return typeHandler;
        }

        protected Criterion(String condition) {
            super();
            this.condition = condition;
            this.typeHandler = null;
            this.noValue = true;
        }

        protected Criterion(String condition, Object value, String typeHandler) {
            super();
            this.condition = condition;
            this.value = value;
            this.typeHandler = typeHandler;
            if (value instanceof List<?>) {
                this.listValue = true;
            } else {
                this.singleValue = true;
            }
        }

        protected Criterion(String condition, Object value) {
            this(condition, value, null);
        }

        protected Criterion(String condition, Object value, Object secondValue, String typeHandler) {
            super();
            this.condition = condition;
            this.value = value;
            this.secondValue = secondValue;
            this.typeHandler = typeHandler;
            this.betweenValue = true;
        }

        protected Criterion(String condition, Object value, Object secondValue) {
            this(condition, value, secondValue, null);
        }
    }
}